dsh-edit-turn 0.5.4 → 0.5.5

package/README.md

@@ -142,7 +142,6 @@ ctx.sessions.registerMessageProjection({
 | 路由 | `GET /dsh-edit-turn/state?sessionId=` | 可编辑轮次、已遮蔽行账本（`hidden` + `revisions`）、surface、忙碌状态；`mode` 是 `patch` 或 `replay`；`patches[]` 是已落地的就地补丁；回复项带 `blocks[]`（`index` / `kind` / 当前投影 `text` / `original` / `patched`） |
 | 路由 | `POST /dsh-edit-turn/apply` | 提示词：`{ sessionId, seq \| messageId \| turn, text, parts? }`；就地回复：再加 `blockIndex` + `kind`（`text` / `reasoning`）。写入改后内容；`parts` 是要保留/新增的块列表（`[{ keep } \| { add: { data, mediaType?, name? } }]`，缺省 = 老客户端的纯文字载体）；响应含 `applied` / `shadowed` / `replacementSeq` / `dropped` / `blocks`；改后文本与当前活文本一字不差**且块列表与原消息相同**时什么都不写，响应改为 `applied:false` + `unchanged:true` + `shadowed:[]`（`original` 是它比较的那份文本）。这是一个**标志，不是拒绝**：调用方自己决定下一步（编辑器的「重跑」正是靠它继续发起重跑） |
 | 路由 | `GET /dsh-edit-turn/attachment?sessionId=&seq=&index=` | 只读：该会话日志确实引用过的那个块的原始字节（芯片缩略图用）；回环 + 同源 + 只认本会话引用过的引用，取不到就 404（芯片退回显示名字）。它**只用于显示**，改写路径完全不经过它 |
-| 工具 | `edit_turn_targets` | 只读：列出该会话当前可编辑的轮次、回复与每条回复的可编辑块（供 agent 自查） |
 | 前端 | `conversation.input.overlay` | 每会话控制器：编辑入口、就地编辑器、被遮蔽行的隐藏账本 |
 
 ### 跨插件契约（给兄弟插件）
@@ -195,7 +194,7 @@ DSH_BIN=/path/to/dsh/lib/bin.js PORT=4123 DSH_HOME=/tmp/dsh-edit-turn-home bash
 
 **「两支铅笔该落在哪儿」同样已被覆盖**，这是按你给的规范改的：用户行那颗笔排在**动作条的最右边**（时间、复制、以及兄弟插件后插进来的按钮之后），回复行那颗笔排在**动作条的最左边**（复制按钮之前）。两处都不是"换个插入点"能办到的，各自卡在一个宿主限制上：折叠行原先把笔塞进替代气泡的字外留白里（要悬停改写文本才看得见，也够不着"复制"）；回复笔受宿主注册的 slot 约束，DOM 上必然排在平台自己画的复制按钮之后。现在的做法是：①`renderRevision` 把改写后的笔**交给那条活下来的动作条**（`injectRowAction(row, editTarget, …)`），同时把它从气泡里摘掉，只有行彻底没有条可留时才退回气泡字外留白；`applyDom` 在行可见时**只在没有替代气泡站位时**才拆掉行上的笔——否则会把上一行刚放进去的笔拆走。②回复笔靠新增的 `.dshet-reply-action` 加 flex `order:-1` 冲到最左，因为那一格宿主是 `display:contents`，DOM 序永远只能第二，只有顺序属性改得动；用户笔同理——兄弟插件（`dsh-delete-turn`）会在任意时刻把垃圾桶**追加**进同一条动作条，DOM 插入序保不住右端，所以 `.dshet-action-host` 带 `order:9`，无论谁后插都在它左边。颜色也一并对齐平台：`.dshet-action` 改用平台的 `--dsw-alias-label-tertiary`（悬停 `--dsw-alias-label-primary`，留一个等于默认主题取值的兜底），不再用自己的蓝灰墨色——此前它比旁边的复制/垃圾桶更蓝，看起来像另一个控件；实测两者计算色都是 `rgb(129, 133, 140)`。测试上：原"铅笔在字外留白"的用例改写为「铅笔并进那条活下来的条的末尾、气泡里不再留笔」，无条用例补上"留白里仍有笔"，回复 entry 用例补 class 断言；静态检查加 4 条钉住这一批写法（含「气泡按内容收窄」），另加 1 条钉住 `order:9`，`verify:live` 加 2 个下发标记；`verify:ui` 的「行末尾的笔」断言改成**按布局量右边缘**（DOM 序不算数）并已在真机重载后跑通——现场那个用户条是 `时间 → 复制 → 垃圾桶 → 笔`，笔在最右（原始会话/切走的会话/切回后三处确认）。三处新写法各做过反向复现：把「笔交给动作条」「`.dshet-reply-action` class」「`applyDom` 的站位守卫」逐一还原，各有一个用例失败（守卫那处失败在「笔并进条末尾」用例上——它恰好也钉住了"刚放好又被拆走"这条回归）。当前 `npm run check` **105 项** + 契约 + 静态全绿。
 
-**开发前置**：`npm test` 与两个 `verify:*` 需要 `@deepseek-ai/dsh-session` 与 `@deepseek-ai/dsh-tools` 可解析。本插件自身不依赖它们（宿主半部只 import `schemastery` 与 `dsh-tools`），测试需要一个装了 DSH 的 `node_modules`：
+**开发前置**：`npm test` 与两个 `verify:*` 需要 `@deepseek-ai/dsh-session` 与 `@deepseek-ai/dsh-settings` 可解析。本插件运行时不依赖它们（宿主半部只 import `schemastery` 与 `dsh-session`，后者由宿主提供），测试需要一个装了 DSH 的 `node_modules`：
 
 ```sh
 ln -s /path/to/dsh-install/node_modules ./node_modules
@@ -233,7 +232,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
    cd <插件目录> && rm -f node_modules && npm install --omit=dev --legacy-peer-deps
    ```
 
-   注意区分两类依赖：宿主提供的 **peer**（`dsh-tools`、`dsh-settings`）由 DSH 加载器解析，可以不装；**普通 dependencies**（如 `schemastery`）必须能解析到，加载器不会替你找。
+   注意区分两类依赖：宿主提供的 **peer**（`dsh-settings`、`dsh-session`）由 DSH 加载器解析，可以不装；**普通 dependencies**（如 `schemastery`）必须能解析到，加载器不会替你找。
 3. **加载了但没入口时**，用只读诊断路由看浏览器半部到底问了什么：
 
    ```sh
@@ -278,6 +277,18 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.5.5** —— 不再向模型暴露任何工具；新增会话日志裁剪工具。
+
+- **模型工具移除**：本插件原先注册了一个模型可见的工具（`edit_turn_targets`，给模型列可编辑的轮次/步骤）。它其实用不上——编辑是靠 UI 面板做的，模型不需要知道这件事——而且它把 `dsh-tools` 平台拖成了硬依赖。现在整个工具拿掉，插件不再注册任何模型可见的工具，也不再依赖 `dsh-tools`。
+
+- **新增 `tools/compact-session.mjs`（会话日志裁剪）**：长会话的日志会一路涨到十几 MB，而宿主的压缩是**累积**的——每个检查点覆盖前一个，所以更早的窗口对模型早已不可见，却还压在日志里、还显示在对话区。这个工具按窗口裁剪：只保留最后 N 个窗口（`--keep-windows N`），把更早的窗口整段切掉，同时把受影响的引用全部重编。
+
+  它按"先算后写"走：默认只写临时文件并打印试算结果，`--apply` 才落盘，落盘前检查 `session.lock`（宿主正打开着的会话一律拒绝），落盘时把原文件改名为 `<日志>.precompact-<时间戳>` 再原子写入。
+
+  裁剪不是简单截断——宿主对日志有三层校验（格式层 `dsh-session-format-v3-to-v4`、会话层 `dsh-session`、投影层 inbox 拼接），任何一处不合法整份日志都加载不了。所以工具会重排与重编：切点退到 `turn/start`（检查点不是轮次边界）、轮次与步骤从 1 重编号、系统提示词放进第一对 `turn/start`+`step/start` 之后（它必须落在已打开的轮次里，同时仍是第一个表面节点）、所有 `*Seq`/`*Seqs`/`*Range` 交叉引用统一重编（`throughSeq` 除外——它指向**别的会话**的日志）、compaction 的记账字段按模拟出的表面现算、`compaction/summary` 没了就把整组丢掉、inbox 拼接记录先重放拿到最终状态再决定去留。
+
+  实测：13.2 MB / 29,496 事件的会话裁到 4.8 MB / 9,302 事件，而**模型看到的内容完全不变**（可见节点 1000 → 1000）。
+
 **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}$/`，仍然挡住 `/`、`\`、`..`、空白与控制字符。
@@ -389,7 +400,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
   1. `lib/patch.js`：`PATCH_TYPE = 'plugin:dsh-edit-turn/patch'`，记录载荷 `{ version, targets: [{ seq, blockIndex, kind, text }] }`；`patchProjection()` 按 seq 分组、以「已投影消息」为 base 叠加多条记录，改思维链时删除 `signature` / `thinkingSignature`；
   2. `apply` 现场探测 `appendPluginRecord` 与 `ctx.sessions.registerMessageProjection`，成功才启用 patch 模式（`/debug` 的 `mode` 可查）；任一缺失退回重放，`replyMode: 'patch'` 则直接报错；
   3. `planRollback` 的回复分支在 patch 模式下只解析目标块（`blockIndex` / `kind`），不计算窗口、不碰 turn；`applyEdit` 只调一次 `appendPluginRecord` 再 flush；
-  4. `/state` 返回 `mode`、`patches[]`、每条回复的 `blocks[]`（`index` / `kind` / 当前投影 `text` / `original` / `patched`）；`edit_turn_targets` 工具也列出块。
+  4. `/state` 返回 `mode`、`patches[]`、每条回复的 `blocks[]`（`index` / `kind` / 当前投影 `text` / `original` / `patched`）。
 - **客户端**：回复编辑器加块选择器；保存只发 `blockIndex` / `kind` / `text`；正文补丁在宿主 markdown 容器里就地替换，思维链补丁在回复下方显示注记。原始行、动作条、工具卡片都不动。
 - **兼容**：没有投影能力的宿主继续走 0.2.21 重放；`replyMode: replay` 可强制旧路径；卸载插件并重启宿主后投影消失，模型与 UI 都回到记录里的原文——这是 overlay 机制与 surface 事件的取舍，README 的「工作原理」已写明。
 - **测试**：`npm test` **205/205**、`npm run verify:contract` **96** 项、`npm run verify:client` **184** 项；新增 9 条纯 patch 用例、3 条宿主 patch 用例（一条记录、无 turn、投影叠加、思维链签名去掉、unchanged 不写、热重载复用投影）、4 条客户端 DOM 用例（块选择器、保存载荷、正文就地显示、思维链注记），沙箱 `verify:profile` 新增「真实 profile 中 `mode=patch` 且 `appendPluginRecord` 可用」的探针。
@@ -572,7 +583,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 - `dsh.engines.dsh`: `>=0.1.6-alpha.2`（本插件依赖该版本的消息行定义与 surface 语义；`0.1.6-alpha.2` 与 `0.1.7-rc.1` 均已实测）。
 - 客户端依赖：`dsh-client-locale`、`dsh-client-ui-chat`、`dsh-client-ui-conversation`、`dsh-client-ui-primitives`。
-- 宿主依赖：`dsh-settings`、`dsh-tools`（peer）；`@deepseek-ai/schemastery`（直接依赖）。
+- 宿主依赖：`dsh-settings`、`dsh-session`（peer）；`@deepseek-ai/schemastery`（直接依赖）。
 
 ### License
 
@@ -772,7 +783,6 @@ first `session.append`, so a refused upload (too large, malformed bytes) answers
 | Route | `GET /dsh-edit-turn/state?sessionId=` | Editable turns, the hidden-row ledger (`hidden` + `revisions`), the surface, busy state |
 | Route | `POST /dsh-edit-turn/apply` | `{ sessionId, seq \| messageId \| turn, text, parts? }` → write the revised text; `parts` is the block list to keep and add (`[{ keep } \| { add: { data, mediaType?, name? } }]`; omitted means the text-only carrier an older client sends); the response carries `applied` / `shadowed` / `replacementSeq` / `dropped` / `blocks` |
 | Route | `GET /dsh-edit-turn/attachment?sessionId=&seq=&index=` | Read-only: the raw bytes of one block the session's own log cites (a chip's thumbnail). Loopback and same-origin only, and it serves nothing no session references; a miss answers 404 and the chip falls back to its label. Display only - the edit path never goes through it |
-| Tool | `edit_turn_targets` | Read-only: list the session's editable turns and their text |
 | Client | `conversation.input.overlay` | Per-session controller: edit entry, in-place editor, hidden-row ledger |
 
 ### Cross-plugin contract (for sibling plugins)
@@ -1011,9 +1021,10 @@ checks pin the container shape and the IME guard; `verify:live` carries the
 marker.
 
 **Development prerequisite:** `npm test` and both `verify:*` commands need
-`@deepseek-ai/dsh-session` and `@deepseek-ai/dsh-tools` to resolve. The plugin
+`@deepseek-ai/dsh-settings` and `@deepseek-ai/dsh-session` to resolve. The plugin
 itself does not depend on them (the host half imports only `schemastery` and
-`dsh-tools`), so tests need a `node_modules` from a DSH installation:
+`dsh-session`, the latter provided by the host), so tests need a `node_modules`
+from a DSH installation:
 
 ```sh
 ln -s /path/to/dsh-install/node_modules ./node_modules
@@ -1051,7 +1062,7 @@ Separate "the plugin never loaded" from "it loaded but nothing rendered" - the t
    cd <plugin dir> && rm -f node_modules && npm install --omit=dev --legacy-peer-deps
    ```
 
-   Mind the two kinds of dependency: **peers** provided by the host (`dsh-tools`, `dsh-settings`) are resolved by the DSH loader and need no install; **regular dependencies** (like `schemastery`) must resolve on their own - the loader will not find them for you.
+   Mind the two kinds of dependency: **peers** provided by the host (`dsh-settings`, `dsh-session`) are resolved by the DSH loader and need no install; **regular dependencies** (like `schemastery`) must resolve on their own - the loader will not find them for you.
 3. **"One session shows no edit entries at all while `/dsh-edit-turn/state` answers 404 in its console"**: that session is being **held by another DSH instance** (the desktop app has it open, or vice versa). A session can only belong to one instance at a time - host behaviour, not a plugin problem. Use it from that instance, or release it in the other one first. `verify:ui` notes and skips this case instead of failing.
 4. **"The history fails to load / one session is unreadable"** (`session-not-found`,
 with `SessionFormatError` in the console): this can be a log broken by the reply
@@ -1087,7 +1098,7 @@ byte-for-byte backup - truncates at the first event the reader refuses:
 
 - `dsh.engines.dsh`: `>=0.1.6-alpha.2` (this plugin relies on that release's message-row definitions and surface semantics, and was verified on it).
 - Client dependencies: `dsh-client-locale`, `dsh-client-ui-chat`, `dsh-client-ui-conversation`, `dsh-client-ui-primitives`.
-- Host dependencies: `dsh-settings`, `dsh-tools` (peers); `@deepseek-ai/schemastery` (direct).
+- Host dependencies: `dsh-settings`, `dsh-session` (peers); `@deepseek-ai/schemastery` (direct).
 
 ### License
 

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.4'
+    const PLUGIN_VERSION = '0.5.5'
 
     // --- copy -----------------------------------------------------------------
 
@@ -60,6 +60,8 @@ window.__ModuleLoader__.load({
       'copy': '复制',
       'copied': '复制成功',
       'action.copied': '复制成功',
+      'action.copy': '复制这条回答',
+      'action.tail-actions': '这一轮的动作',
       'editor.title': '编辑这条消息',
       'editor.title-reply': '编辑这条回答',
       'editor.placeholder': '改成你希望自己当时说的内容。保存后就地替换这条消息，后面的对话保持不变。',
@@ -147,6 +149,8 @@ window.__ModuleLoader__.load({
       'copy': 'Copy',
       'copied': 'Copied',
       'action.copied': 'Copied',
+      'action.copy': 'Copy this reply',
+      'action.tail-actions': 'Actions for this turn',
       'editor.title': 'Edit this message',
       'editor.title-reply': 'Edit this reply',
       'editor.placeholder': 'Write what you want to have said. Saving replaces this message in place; the conversation after it stays as it is.',
@@ -424,6 +428,18 @@ window.__ModuleLoader__.load({
       // variable resolves on the action bar (and everywhere above it); the
       // fallback is the value it resolves to in the default theme.
       '.dshet-action{width:28px;height:28px;padding:6px;display:inline-flex;align-items:center;justify-content:center;border:none;border-radius:28px;background:transparent;color:var(--dsw-alias-label-tertiary,#81858c);cursor:pointer;transition:background-color .12s,color .12s}',
+      // The fallback strip for a turn with no closing body.
+      //
+      // The gate is the host's OWN marker: TurnTailNodeView renders
+      // `data-actions-reveal` on the tail container exactly on the branch that
+      // also draws the official action row, and never on the branch that has
+      // none. So one rule hides this strip wherever the official one exists -
+      // the two can never be drawn together, and no observer is needed.
+      '.dshet-tail{display:inline-flex;align-items:center;gap:2px;margin-left:4px}',
+      '[data-turn-tail][data-actions-reveal] .dshet-tail{display:none}',
+      '.dshet-tail[data-reveal=always]{opacity:1}',
+      '@media (hover:hover){.dshet-tail[data-reveal=hover]{opacity:0;transition:opacity 80ms}[data-turn-tail]:hover .dshet-tail[data-reveal=hover],[data-turn-tail]:focus-within .dshet-tail[data-reveal=hover]{opacity:1}}',
+      '.dshet-tail-action[data-copied=1]{color:var(--dshet-accent,#4d6bfe)}',
       '.dshet-action:hover:not(:disabled){background:var(--dshet-chip);box-shadow:inset 0 0 0 1px var(--dshet-line);color:var(--dsw-alias-label-primary,var(--dshet-ink))}',
       '.dshet-action:focus-visible{outline:2px solid var(--dsw-alias-button-primary-fill,var(--dshet-accent));outline-offset:2px}',
       '.dshet-action:disabled{cursor:default;opacity:.4}',
@@ -579,12 +595,18 @@ window.__ModuleLoader__.load({
     ].join('')
 
     const TAG_ID = 'dsh-edit-turn/edit-turn.css'
-    if (typeof document !== 'undefined' && document.querySelector('style[data-plugin-css=' + JSON.stringify(TAG_ID) + ']') === null) {
-      const tag = document.createElement('style')
-      tag.dataset.plugin = NS
-      tag.dataset.pluginCss = TAG_ID
-      tag.textContent = CSS
-      document.head.appendChild(tag)
+    if (typeof document !== 'undefined') {
+      // Reused, not skipped: an upgrade over a live page finds the tag the
+      // PREVIOUS build injected, and leaving it alone kept the new rules out of
+      // the page entirely.
+      let tag = document.querySelector('style[data-plugin-css=' + JSON.stringify(TAG_ID) + ']')
+      if (tag === null) {
+        tag = document.createElement('style')
+        tag.dataset.plugin = NS
+        tag.dataset.pluginCss = TAG_ID
+        document.head.appendChild(tag)
+      }
+      if (tag.textContent !== CSS) tag.textContent = CSS
     }
 
     // --- icon -----------------------------------------------------------------
@@ -3697,9 +3719,12 @@ window.__ModuleLoader__.load({
         error.className = 'dshet-error'
         error.setAttribute('role', 'status')
         const detail = typeof view.failureDetail === 'string' && view.failureDetail !== '' ? view.failureDetail : null
-        error.textContent = (failureCode === 'internal' || failureCode === 'generic') && detail !== null
-          ? `${errorText(t, failureCode)}（${detail.slice(0, 300)}）`
-          : errorText(t, failureCode)
+        // The host's own sentence is always shown: a code-only message leaves the
+        // reader with nothing to act on, and it is what made a real 400 impossible
+        // to diagnose.
+        error.textContent = detail === null
+          ? errorText(t, failureCode)
+          : `${errorText(t, failureCode)}（${detail.slice(0, 300)}）`
         box.appendChild(error)
       }
 
@@ -4533,6 +4558,211 @@ window.__ModuleLoader__.load({
       })
     }
 
+    // --- the fallback strip ---------------------------------------------------
+    //
+    // TurnTailNodeView, when a turn's model reply has no closing body
+    // (`closing === null`), returns the turnTail slot alone and never renders
+    // `conversation.chat.assistant-actions`. Every action on that row goes with
+    // it - this plugin's pencil, and the platform's own copy, branch, feedback
+    // and usage buttons too. Nothing a plugin registers inside a strip that is
+    // not rendered can bring those back, so the fallback lives in the one slot
+    // that branch DOES render.
+    //
+    // It is not a second bar for every turn: the host puts `data-actions-reveal`
+    // on the tail container only on the branch that draws its own strip, and one
+    // CSS rule hides this one wherever that attribute is present.
+
+    /**
+     * The reply this turn's fallback strip acts on.
+     *
+     * A turn runs several steps and the strip belongs at the end of the turn,
+     * so the LAST rewriteable reply of that turn wins - the same row the host
+     * would have hung its own strip on.
+     *
+     * @param view - the controller snapshot (see readReplyView).
+     * @param turn - the TurnLocation the slot hands over.
+     * @returns the reply entry, or undefined when this turn has none.
+     */
+    function replyForTurn(view, turn) {
+      if (view === null || view === undefined || typeof turn !== 'number') return undefined
+      const replies = view.replies
+      if (replies === null || replies === undefined || typeof replies.values !== 'function') return undefined
+      if (view.hidden === null || view.hidden === undefined || typeof view.hidden.has !== 'function') return undefined
+      let best
+      for (const reply of replies.values()) {
+        if (reply === null || typeof reply !== 'object') continue
+        if (typeof reply.seq !== 'number' || reply.turn !== turn) continue
+        if (view.hidden.has(reply.seq)) continue
+        if (best === undefined || reply.seq > best.seq) best = reply
+      }
+      return best
+    }
+
+    /**
+     * What a copy press on the fallback strip writes.
+     *
+     * The model's own answer when the turn has one, and its reasoning when the
+     * whole reply went into thinking - the case this strip exists for. Blocks
+     * are joined the way they read, blank ones dropped so a trailing empty
+     * block does not become a trailing newline.
+     *
+     * @param entry - one reply entry.
+     * @returns the text to copy; empty when there is nothing readable.
+     */
+    function replyCopyText(entry) {
+      const blocks = entry !== null && entry !== undefined && Array.isArray(entry.blocks) ? entry.blocks : []
+      const gather = (kind) =>
+        blocks
+          .filter((block) => block !== null && typeof block === 'object' && block.kind === kind)
+          .map((block) => (typeof block.text === 'string' ? block.text : ''))
+          .filter((text) => text.trim() !== '')
+          .join('\n\n')
+      const answer = gather('text')
+      return answer !== '' ? answer : gather('reasoning')
+    }
+
+    function CopyIcon() {
+      return jsx('svg', {
+        width: 16,
+        height: 16,
+        viewBox: '0 0 16 16',
+        fill: 'none',
+        'aria-hidden': true,
+        children: [
+          jsx('rect', { x: 5.2, y: 5.2, width: 8, height: 8, rx: 1.6, stroke: 'currentColor', strokeWidth: 1.2 }, 0),
+          jsx('path', { d: 'M10.8 5.2V3.6A1.6 1.6 0 0 0 9.2 2H3.6A1.6 1.6 0 0 0 2 3.6v5.6a1.6 1.6 0 0 0 1.6 1.6h1.6', stroke: 'currentColor', strokeWidth: 1.2, strokeLinecap: 'round' }, 1),
+        ],
+      })
+    }
+
+    function CheckIcon() {
+      return jsx('svg', {
+        width: 16,
+        height: 16,
+        viewBox: '0 0 16 16',
+        fill: 'none',
+        'aria-hidden': true,
+        children: jsx('path', { d: 'M3.2 8.4l3.2 3.2 6.4-6.4', stroke: 'currentColor', strokeWidth: 1.4, strokeLinecap: 'round', strokeLinejoin: 'round' }, 0),
+      })
+    }
+
+    /**
+     * The fallback strip for a turn the host draws no action row for.
+     *
+     * @param props - the slot's owner props ({ turn, seq, openFile }) plus the
+     *   injected controller, the standard `useChat` and this plugin's `t`.
+     */
+    function TailActionEntry(input) {
+      const props = input !== null && typeof input === 'object' ? input : {}
+      const turn = props.turn
+      const controller = props.controller
+      const t = typeof props.t === 'function' ? props.t : null
+      const useChat = props.useChat
+      const [view, setView] = react.useState(() => {
+        try {
+          return readReplyView(controller)
+        } catch {
+          return null
+        }
+      })
+      const [copied, setCopied] = react.useState(false)
+      react.useEffect(() => {
+        let unsubscribe = null
+        try {
+          setView(readReplyView(controller))
+          if (controller !== null && controller !== undefined && typeof controller.subscribe === 'function') {
+            unsubscribe = controller.subscribe(() => setView(readReplyView(controller)))
+          }
+        } catch {
+          setView(null)
+        }
+        return () => {
+          if (typeof unsubscribe === 'function') unsubscribe()
+        }
+      }, [controller])
+      // The host reveals the latest turn's row always and older ones on hover.
+      // The same rule, from the same source it uses (the last turn in the
+      // timeline), so the strip does not behave differently from the row it
+      // stands in for.
+      const lastTurn = typeof useChat === 'function'
+        ? useChat((state) => {
+            if (state === null || typeof state !== 'object') return undefined
+            const timeline = state.timeline
+            const order = timeline === null || timeline === undefined ? null : timeline.turnOrder
+            if (!Array.isArray(order) || order.length === 0) return undefined
+            return order[order.length - 1]
+          })
+        : undefined
+      const entry = replyForTurn(view, turn)
+      // Nothing this plugin can act on: the strip stays out of the way rather
+      // than drawing an empty row.
+      if (entry === undefined) return null
+      const label = t === null ? '' : t('action.edit-reply')
+      const copyLabel = t === null ? '' : t(copied ? 'action.copied' : 'action.copy')
+      const open = (event) => {
+        event.preventDefault()
+        event.stopPropagation()
+        controller.open({
+          anchor: event.currentTarget,
+          seq: entry.seq,
+          mode: 'reply',
+          turn: entry.turn,
+          messageId: entry.messageId,
+          text: typeof entry.text === 'string' ? entry.text : '',
+          attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+          ...(Array.isArray(entry.blocks) ? { blocks: entry.blocks, patch: true } : { blocks: [] }),
+        })
+      }
+      const copy = (event) => {
+        event.preventDefault()
+        event.stopPropagation()
+        const text = replyCopyText(entry)
+        if (text === '') return
+        const write = primitives !== null && primitives !== undefined && typeof primitives.writeClipboard === 'function'
+          ? primitives.writeClipboard
+          : typeof navigator !== 'undefined' && navigator.clipboard && typeof navigator.clipboard.writeText === 'function'
+            ? (value) => navigator.clipboard.writeText(value)
+            : null
+        if (write === null) return
+        Promise.resolve()
+          .then(() => write(text))
+          .then(
+            () => {
+              setCopied(true)
+              window.setTimeout(() => setCopied(false), 1200)
+            },
+            () => {},
+          )
+      }
+      return jsxs('div', {
+        className: 'dshet-tail',
+        'data-reveal': lastTurn === turn ? 'always' : 'hover',
+        role: 'toolbar',
+        'aria-label': t === null ? undefined : t('action.tail-actions'),
+        children: [
+          jsx('button', {
+            type: 'button',
+            className: 'dshet-action dshet-tail-action',
+            'aria-label': label,
+            title: label,
+            onClick: open,
+            key: 'edit',
+            children: jsx(PencilIcon, {}),
+          }),
+          jsx('button', {
+            type: 'button',
+            className: 'dshet-action dshet-tail-action',
+            'data-copied': copied ? '1' : undefined,
+            'aria-label': copyLabel,
+            title: copyLabel,
+            onClick: copy,
+            key: 'copy',
+            children: copied ? jsx(CheckIcon, {}) : jsx(CopyIcon, {}),
+          }),
+        ],
+      })
+    }
+
     // --- react entries --------------------------------------------------------
 
     function OverlayEntry({ useChat, useEditTurn, controller, t }) {
@@ -5014,6 +5244,23 @@ window.__ModuleLoader__.load({
       // The row's configure arrow in the plugin manager. Without this the
       // component page is a read-only overview (the card cannot be opened); the
       // key is the manager's `<bundle package>#<row id>` contract.
+      // The fallback strip, for turns the host draws no action row for (see
+      // TailActionEntry). Order 40 keeps it after the shipped contributors
+      // (schedule sits at 20). It is hidden by CSS wherever the host's own strip
+      // exists, so ordering only matters on the turns it appears at all.
+      ctx.slots.inject('conversation.chat.turnTail', () =>
+        ctx.slots.register(
+          {
+            name: 'conversation.chat.turnTail',
+            id: 'edit-turn-tail',
+            order: 40,
+            locale: NS,
+            inject: (sessionId) => ({ controller: controllerFor(sessionId) }),
+          },
+          TailActionEntry,
+        ),
+      )
+
       ctx.slots.inject('plugins.row.config', () =>
         ctx.slots.register(
           {

package/lib/index.js

@@ -39,9 +39,8 @@
 // is why an `assistant/message` carrier is impossible (it forbids
 // `sourceEventSeqs` outright).
 //
-// The module resolves `@deepseek-ai/schemastery` defensively. `dsh-tools` is a
-// host-provided peer (the loader resolves it for every plugin), but the schema
-// package is a regular dependency: when it cannot be resolved - a pruned
+// The module resolves `@deepseek-ai/schemastery` defensively. The schema package
+// is a regular dependency: when it cannot be resolved - a pruned
 // package cache, an installation that skipped dependencies - a static import
 // takes the whole plugin down and the feature simply disappears from the UI
 // with nothing but a line on the host's stdout to explain it. A guarded require
@@ -50,7 +49,6 @@
 import { randomUUID } from 'node:crypto'
 import { readFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
-import { defineTool } from '@deepseek-ai/dsh-tools'
 import * as sessionApi from '@deepseek-ai/dsh-session'
 import {
   PATCH_TYPE,
@@ -80,7 +78,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.4'
+export const PLUGIN_VERSION = '0.5.5'
 
 // 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
@@ -2335,62 +2333,6 @@ function sessionIdFromExec(exec) {
   return undefined
 }
 
-function registerTool(ctx, config) {
-  const tools = ctx.get('tools')
-  if (!tools || typeof tools.register !== 'function') return
-  tools.register(
-    defineTool({
-      name: 'edit_turn_targets',
-      description:
-        'List the user turns and model replies of a DeepSeek Harness session that the edit-turn plugin can rewrite, with each message\'s current text and, for a reply, every editable block (output text and reasoning). A prompt is replaced where it stands; a reply block is patched in place when the host supports projections, otherwise the reply correction is appended and the later turns are replayed behind it. Read-only: it changes nothing.',
-      parameters: {
-        sessionId: {
-          type: 'string',
-          description: 'Session id to inspect. Defaults to the session this agent is running in.',
-        },
-        limit: { type: 'number', description: 'Maximum number of turns to return (default 20).' },
-      },
-      output: {
-        schema: { type: 'string' },
-        render: (_args, value) => [{ type: 'text', text: value }],
-      },
-      async execute(args, exec) {
-        const sessionId = typeof args.sessionId === 'string' && args.sessionId !== '' ? args.sessionId : sessionIdFromExec(exec)
-        if (sessionId === undefined) {
-          throw new Error('no sessionId was supplied and the calling agent has no session')
-        }
-        const events = await readEvents(ctx, sessionId)
-        if (!events) throw new Error(`no session log for ${sessionId}`)
-        const nodes = surfaceOf(ctx, sessionId, events)
-        const patches = patchesOf(events)
-        const turns = editableTurns(events, nodes)
-        const replies = editableReplies(events, nodes, { patches, patch: config && config.patch === true })
-        const limit = typeof args.limit === 'number' && args.limit > 0 ? Math.floor(args.limit) : 20
-        const shown = turns.slice(-limit)
-        const shownReplies = replies.slice(-limit)
-        const lines = [
-          `session ${sessionId}: ${turns.length} editable turn(s), ${replies.length} editable reply/replies, ${isBusy(events) ? 'BUSY' : 'idle'}`,
-        ]
-        for (const turn of shown) {
-          const preview = turn.text.length > 160 ? `${turn.text.slice(0, 160)}...` : turn.text
-          lines.push(`- turn ${turn.turn} (seq ${turn.seq}, ${turn.attachments} attachment(s)): ${preview}`)
-        }
-        if (turns.length > shown.length) lines.push(`(${turns.length - shown.length} earlier turn(s) omitted)`)
-        for (const reply of shownReplies) {
-          const preview = reply.text.length > 160 ? `${reply.text.slice(0, 160)}...` : reply.text
-          const blocks = Array.isArray(reply.blocks)
-            ? ` [${reply.blocks.map((block) => `${block.index}:${block.kind}${block.patched ? '*' : ''}`).join(', ')}]`
-            : ''
-          lines.push(`- reply (seq ${reply.seq}, ${reply.attachments} non-text part(s))${blocks}: ${preview}`)
-        }
-        if (replies.length > shownReplies.length) lines.push(`(${replies.length - shownReplies.length} earlier reply/replies omitted)`)
-        lines.push('editing a turn replaces its wording in place (no model call); editing a reply block patches it in place when the host supports plugin-record projections, otherwise it replaces the reply and replays the tail. Re-running a turn is dsh-rerun-turn\'s button.')
-        return lines.join('\n')
-      },
-    }),
-  )
-}
-
 // --- http --------------------------------------------------------------------
 
 function isLoopbackAddress(address) {
@@ -2792,12 +2734,6 @@ export function apply(ctx, config) {
     ctx.inject(['webServer'], (sub) => registerRoutes(sub.webServer, sub))
   }
 
-  const tools = ctx.get('tools')
-  if (tools) {
-    registerTool(ctx, resolved)
-  } else {
-    ctx.inject(['tools'], (sub) => registerTool(sub, resolved))
-  }
 }
 
 export default apply

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "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",
@@ -52,7 +52,6 @@
   },
   "peerDependencies": {
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.7 || ^0.1.1-rc.2 || ^0.1.2-alpha.2 || ^0.1.3-alpha.2 || ^0.1.5-alpha.1 || ^0.2.0-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.7 || ^0.1.1-rc.2 || ^0.1.2-alpha.2 || ^0.1.3-alpha.2 || ^0.1.5-alpha.1 || ^0.2.0-rc.1",
     "@deepseek-ai/dsh-session": "^0.2.0-rc.1 || ^0.2.1-rc.2"
   },
   "dsh": {