dsh-edit-turn 0.2.15 → 0.2.17

package/README.md

@@ -114,11 +114,13 @@ session.append('developer/message', { turn, step, message: { role: 'developer',
 1. **prompt 编辑保持单节点窗口**：`planRollback` 的 `mode === 'prompt'` 只遮蔽目标那一格（`shadowed = [target.seq]`），不会顺手回退到末尾；
 2. **替换事件与目标同事件类型**：改 `user/message` 落下的就是 `user/message`（回复编辑不换类型就换不了位，见第 5 条）；
 3. **`sourceEventSeqs` 永远列全窗口**：官方校验要求完整覆盖，缺一个节点事件会被拒；
-4. **每个替换都带语义标记**：`source.kind === 'plugin:dsh-edit-turn'` 且 `source.editedBy === 'dsh-edit-turn'`——包括那个不含文本的空 `developer/message` 载体，兄弟插件按 `editedBy` 识别即可，不必靠推断窗口形状；
+4. **每个替换都带语义标记**：`source.editedBy === 'dsh-edit-turn'`——包括那个不含文本的空 `developer/message` 载体，兄弟插件按 `editedBy` 识别即可，不必靠推断窗口形状；
 5. **回复编辑 = 多节点回退 + 追加新回复**，不是就地替换：旧回复行没有入口是**设计如此**（新行自带入口）。不要为了保住旧行的入口往 `assistant/message` 上加 `sourceEventSeqs`——官方校验会直接拒；
 6. **映射已公开**：`GET /dsh-edit-turn/state` 的 `revisions[]` 给出 `{ replacementSeq, startSeq, endSeq, shadowed }`（字段名与 `POST /apply` 响应一致），`hidden[]` 每题一格列出 `{ seq, turn, replacement }`。跨插件不必再从事件流自行推导。
 
-**`source.kind` 的行为（有意为之）**：prompt 编辑落地的那条 `user/message` 的 `source.kind` 是 `plugin:dsh-edit-turn`，**不是 `user`**。因此凡是以 `source.kind === 'user'` 识别"人类提问"的消费者（例如按人类提问划分回复删除窗口的逻辑），会把这条改写后的提问当作**普通内容**。这是刻意的：它是一段插件写入的文本，不是新的用户发话，平台也就不该再回答它；需要识别它的消费者请用上面的 `revisions`/`editedBy`，不要放宽 `source.kind === 'user'` 的判定。
+**`source.kind` 的行为（这里修过一个坑）**：prompt 编辑落地的那条 `user/message` **保持 `source.kind === 'user'`**，来历记在 `source.editedBy` 上。原因：平台里有近二十处按 `source.kind === 'user'` 认定「这是人类提问」——`dsh-session-turn-outline`（轮次导轨与轨迹视图）、`dsh-client-ui-trajectory`、`dsh-client-ui-chat`、inbox 的 steering 过滤、会话列表的 `lastPromptAt`。载体站在用户的位置上，改掉这个 kind 会让这些消费者**看不见这一轮的提问**：导轨空掉、`turnOutline` 的 `prompt` 变成空串、轨迹视图把提问归到「上下文」而不是「用户」。（0.2.15 及更早就是这样。）
+
+保持 `kind === 'user'` **不会**让它变成「被回答的新输入」：入队根本不看 kind——inbox 投影的 reducer 只处理 `agent/inbox/spliced`（`dsh-agent-loop`），而该事件只由显式的 agent splice 写入；跳过新输入的那些扫描判的是 `surfaceOp === 'append'`，而载体是 `surfaceOp: { op: 'replace' }`。
 
 ### 验证状态
 
@@ -129,7 +131,7 @@ session.append('developer/message', { turn, step, message: { role: 'developer',
 | 运行中的实例是否真的挂载了本插件（只读路由守卫探针，无需 token） | `npm run probe:loaded [端口]` | 通过：`/state` 返 400、`/apply` 返 405 —— 这两个状态码只有本插件会返回 |
 | 浏览器半部到底问了什么、拿回了什么（只读诊断，含失败记录） | `GET /dsh-edit-turn/debug` | 通过：真实浏览器里确认客户端确实拿到 replies；并复现了旧 v3 会话的 session-not-found |
 | 官方 append **与读取**契约（真实校验器，进程内） | `npm run verify:contract` | 80 项通过（每段写入后都用加载器重读整份日志）：替换事件被接受、派生历史真的收缩、日志 append-only、工具结果与调用同进同退、空 developer 载体不产生模型消息、**连续两次回退都被接受**、**编辑模型回答的完整机制被接受**、**跨插件依赖的不变量（单节点窗口 / 同事件类型 / 全窗口 sourceEventSeqs / 每个替换都带 `editedBy` 标记 / 改写后的 `source.kind` 不是 `user` / 修正回复不带 `sourceEventSeqs`）** |
-| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 105 项通过 |
+| 纯逻辑 + 宿主集成 + 客户端 DOM 行为（真 HTTP、真校验器、桩服务、DOM 桩） | `npm test` | 139 项通过 |
 | 客户端半部静态检查（注册、i18n 完整性、样式、皮肤可读性、版本三处同步、线协议） | `npm run verify:client` | 全部通过 |
 | 实机前端产物校验（运行中的 DSH 是否在下发当前代码） | `npm run verify:live -- --token-file ~/path/to/dsh.log` | 全部通过（含**宿主节点形状锚点**） |
 | **真实浏览器渲染冒烟**（CDP 驱动已开着的标签页，只读） | `npm run verify:ui` | 全部通过：下发的字节就是刚改的字节、无槽位崩溃留下的空占位、回复铅笔在平台动作条里、被回滚的行保住动作条、**被回滚的用户行一定显示替代文本（消息不会凭空消失）**、**替代气泡一定排在时间/复制之上（顺序与正常消息一致）**、**改写后那颗铅笔一定在还活着的动作条末尾（已在原始会话、切走的会话、切回后三处现场确认）**、**回复铅笔一定排在动作条最左（复制之前，已现场确认）**、气泡上没有 `.dshet-floating` 压着文字、切走再切回入口仍在 |
@@ -172,6 +174,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 - **回退是持久的，隐藏不是**。回退写进日志后，模型上下文永久改变；转录里那些行的隐藏是本插件客户端半部做的。卸载插件后，旧行会重新显示出来（而模型上下文里的回退仍然生效）——因为替换事件是官方事件，不会随插件消失。
 - 回退后**系统提示词保持不变**（窗口永不包含 surface 节点 0，该节点也永不可编辑）。
 - **旧会话（v3 格式日志）在 DSH 0.1.7 下读不到**：DSH 的会话读取层对这类日志返回 `session-not-found`，本插件因此在其中完全不工作（表现为没有编辑入口）。新写的会话是 v4，正常。
+- **改写过的行，只有转录里的那颗复制按钮被接管**。平台自己画的复制按钮在别处（**轨迹视图** `dsh-client-ui-trajectory`）读的是同一份投影数据，本版没有接管它：在那里复制一条被改写过的消息，仍会拿到改写前的文本。
 
 ### 排查：编辑入口整个不见了
 
@@ -213,6 +216,18 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.2.17** —— 修「改写过的提示词，复制出来还是旧文本」。只修 Bug，交互语义不变。
+
+- **根因在平台侧，但它就在下发的 bundle 里，读得到**：平台的复制按钮把它**画那一行时用的那条消息**交给剪贴板——文本取自投影节点（`dsh-client-ui-chat/lib/client.js:1117` 的 `MessageIconActions` 收一个 `text` prop，`onCopy` 里调 `writeClipboard(text)`，`:1129-1141`；这个 `text` 由 `UserStyleBubble` 从节点数据 `contentParts(data.content)` 解出，`:1398-1404` 把它交出去）。而**改写是替换事件，平台不给它建行**：`messageDefinition.match` 只认 `isAppendSurfaceEvent`（`surfaceOp === 'append'`，`:9267`）。于是那一行永远是**原来那条 append 消息**，行上复制按钮手里是「回复1」，界面上显示「回复2」的却是本插件的替代气泡（`bubble.textContent`）。用户按复制 → 粘出旧文本。**换编辑器无效**：编辑器的文本来自宿主账本（`targetFor` 读 `view.editable`），跟那颗按钮不是一回事。（行号按本机下发版本：DSH `0.2.0-rc.2`。）
+- **修法：接住那颗按钮的按下，平台节点一根手指都不碰**。改写过的行由本插件在**平台自己的**复制按钮上装一个**捕获阶段**的 click 监听（捕获先于宿主挂在 root 上的冒泡处理器），命中即 `stopPropagation`（不让宿主再用旧文本写一次剪贴板），改用**宿主自己的** `writeClipboard`（`@deepseek-ai/dsh-client-ui-primitives`）写入**这一行现在显示的文本**（存在 `data-dshet-copy-text` 上），并自己画出宿主那次「复制成功」：1 秒的勾（样式表 `[data-dshet-copy-flash="1"]`，和宿主一样把图标换成勾）加上宿主自己的文案（`aria-label` 换成「复制成功」，按钮原文案先记在 `data-dshet-copy-label` 里，1 秒后还回去）。
+- **按钮本身不移除、不隐藏、不禁用**（节点归宿主，宿主用自己的 reconciler 卸载它）。**插件走了之后那颗按钮退化成宿主本来的行为（复制原文），而不是变成一颗死按钮**；宿主版本的 `ui-primitives` 若没有 `writeClipboard`，本插件干脆不接管（同样保持宿主行为）。
+- **归属与幂等（I3 / I4）**：接住按钮要用的一切（文本、文案、写入函数）都在**按下那一刻从按钮上读**，所以重载后的新实例能接管旧实例装的那颗监听；`data-dshet-copy-own` 保证同一颗按钮上永远只有一颗监听；行不再被改写、或本插件卸载时，只交还**本插件自己写下的**那些属性（卸载按 `[data-dshet-copy-text]` 全局收回）。兄弟插件的按钮（带自己命名空间的那些）不会被误认成宿主的复制按钮。
+- **不做的**：不改平台代码、不改会话日志；**回复**编辑不受影响（它追加的是**新的一条**回答行，那行自带正确文本）；轨迹视图（`dsh-client-ui-trajectory:5273`）有同一个读法，本版未涉及（见「已知限制」）。
+- **English**: the platform's copy action hands over the text of the message the row was DRAWN for, and a rewritten prompt gets no row of its own (rows are built for append-origin surface events only), so copying from that row pasted the wording the user had replaced. This plugin now answers that press from a capture-phase listener on the host's own copy button - stopping the host's handler from writing the stale text - writes the text the row shows through the host's own `writeClipboard`, draws the host's own one-second "copied" check and label itself, and touches nothing else on the button: never removed, never hidden, never disabled, so a bundle that goes away leaves a working button that copies its own message again.
+- 本版：`npm test` **141/141**、`npm run verify:contract` 80/80、`npm run verify:client` **163/163**（`npm run check` exit 0）；新增 8 条 DOM 用例、6 条静态检查、2 个 `verify:live` 标记。DOM 桩顺带补上 `data-*` 属性与 `dataset` 的**双向反射**（此前只有 dataset→属性 一个方向：`setAttribute('data-...')` 造出来的夹具对 `dataset` 查不到，而浏览器里两者是同一件事）。**负向验证**（`/tmp` 副本，仓库文件未动；逐点还原后只跑 `test/client.dom.test.js`）：整份 `lib/client.js` 还原到 HEAD → **7 条新用例转红**（第 8 条「没被改写的行交给宿主」是不越权的守卫，本就该绿）；逐点：去掉接管调用 → 7 红、恢复行时不再释放 → 1 红、卸载不再收回 → 1 红、去掉 `stopPropagation` → 1 红、不画勾 → 1 红、不还文案 → 1 红、不再删文本标记 → 2 红、不再跳过兄弟按钮 → 1 红、去掉捕获标志 → 1 红、去掉 `data-dshet-copy-own` 优先查找 → 1 红。两套识别（按宿主的文案、按「条里没人认领的第一个按钮」）互为兜底：单独去掉任一条用例仍全绿，**同时去掉正好 2 红**。
+- **验证表里 `npm test` 的旧数字（105）是过期值**，一并改成实测的 139（英文表同处一并改）。
+- **真机提示**：运行中的实例下发的是 profile 里**安装的副本**（`~/.dsh/profiles/web/node_modules/dsh-edit-turn`，仍是 0.2.16），要看到本修复需要**重新安装本目录 + 重启 DSH**；本次没有重启，也没跑 `verify:live` / `verify:ui`（前者需要启动时打印的 token，后者没有可驱动的调试标签页）。
+
 **0.2.15** —— 修一个自己埋的隐患：回复编辑开的合成轮次会让下一次提问撞号。
 
 - **发现**：回复编辑必须在日志里开一个轮次（读路径只在"打开的轮次+步骤"里认 `assistant/message`，修正消息就是 assistant），但 **agent 循环的轮号计数器在 `phase.lastTurn`，是循环构造时播种、只由它自己开的轮推进的**——它看不见我们追加的 `turn/start`。于是下一次提问在同一个会话里会开出**同一个轮号**，两条 `turn/start` 撞号，整份日志在下次加载时报 `turn/start does not open the expected turn`，这正是我们 0.2.4 修掉的那类事故的另一个入口。兄弟插件 dsh-rerun-turn 早踩过并解决了同一问题（其 0.1.1：改用不占轮次的载体 + 事后 `syncLoopTurn`）；我们照做：回复编辑闭合自己的轮次后，**把活循环的 `lastTurn` 推到该轮号**。
@@ -479,11 +494,13 @@ The transcript only builds rows for **append surface events** (ui-chat's user an
 1. **A prompt edit keeps a single-node window**: `planRollback` for `mode === 'prompt'` shadows exactly the message itself (`shadowed = [target.seq]`) and never rolls back to the tail;
 2. **The replacement event has the type of the target**: a `user/message` edit lands a `user/message` (a reply cannot be swapped in place — see 5);
 3. **`sourceEventSeqs` always lists the whole window**: the official validator demands complete coverage; one missing node and the append is refused;
-4. **Every replacement carries the semantic marker**: `source.kind === 'plugin:dsh-edit-turn'` and `source.editedBy === 'dsh-edit-turn'` — including the empty text-free `developer/message` carrier, so siblings can recognise rewrites by `editedBy` alone instead of inferring from the window shape;
+4. **Every replacement carries the semantic marker**: `source.editedBy === 'dsh-edit-turn'` — including the empty text-free `developer/message` carrier, so siblings can recognise rewrites by `editedBy` alone instead of inferring from the window shape;
 5. **A reply edit is a multi-node rollback plus an appended correction**, not an in-place swap: the old reply row keeping no entry is **by design** (the new row carries it). Do not add `sourceEventSeqs` to an `assistant/message` to keep the old row's entry — the official validator refuses it outright;
 6. **The mapping is published**: `revisions[]` on `GET /dsh-edit-turn/state` gives `{ replacementSeq, startSeq, endSeq, shadowed }` (the field names the `POST /apply` response already used), and `hidden[]` lists `{ seq, turn, replacement }` per shadowed row. No sibling has to re-derive the ledger from the event stream.
 
-**The `source.kind` behaviour, intentionally:** after a prompt edit the landed `user/message` has `source.kind === 'plugin:dsh-edit-turn'`, **not `user`**. Any consumer that detects human prompts by `source.kind === 'user'` (for example, partitioning reply-deletion windows by human turns) will classify the revision as ordinary content. That is deliberate: the text was written by a plugin, it is not a fresh human turn, and the platform must not answer it. Consumers that need to find it should use `revisions`/`editedBy` above rather than loosening the `source.kind === 'user'` test.
+**The `source.kind` behaviour — this one was a bug:** after a prompt edit the landed `user/message` **keeps `source.kind === 'user'`**, with the provenance on `source.editedBy`. About twenty places in DSH detect human prompts with `source.kind === 'user'` — `dsh-session-turn-outline` (the turn rail and the Trajectory view), `dsh-client-ui-trajectory`, `dsh-client-ui-chat`, the inbox steering filter, `lastPromptAt` on the session list. The carrier stands in the user's place, so changing that kind made every one of those consumers stop seeing the turn's prompt: the rail lost it, `turnOutline` reported an empty prompt, and the Trajectory view filed the wording under context rather than under the user. (0.2.15 and earlier did exactly that.)
+
+Keeping `kind === 'user'` does **not** turn the carrier into fresh input that gets answered: queueing never reads `kind` — the inbox projection's reducer handles only `agent/inbox/spliced` (`dsh-agent-loop`), and that event is written solely by an explicit agent splice; the scans that skip past fresh input test `surfaceOp === 'append'`, and this carrier is `surfaceOp: { op: 'replace' }`.
 
 ### Verification status
 
@@ -494,7 +511,7 @@ Verified against DSH `0.1.6-alpha.2` and `0.1.7-rc.1`, entirely **without model
 | Is the plugin actually mounted in a running instance? (read-only route-guard probe, no token needed) | `npm run probe:loaded [port]` | pass: `/state` answers 400 and `/apply` answers 405 - status codes only this plugin produces |
 | What the browser half asked for and got back (read-only diagnostics, failures included) | `GET /dsh-edit-turn/debug` | pass: a real browser was confirmed fetching replies, and an old v3 session was reproduced as session-not-found |
 | Official append AND READ contract against the real validator, in process | `npm run verify:contract` | 80 checks pass (every write sequence is reloaded through the reader afterwards): the replacement is accepted, the derived history really shrinks, the log stays append-only, a tool result leaves with its call, the empty developer carrier adds no model message, **two consecutive rollbacks are both accepted**, **the whole reply-editing mechanism is accepted**, **the invariants siblings depend on (single-node window, same event type, full `sourceEventSeqs` coverage, an `editedBy` marker on every replacement, a rewritten prompt whose `source.kind` is not `user`, a correction that carries no `sourceEventSeqs`)** |
-| Pure logic, host integration and browser-half DOM behaviour (real HTTP, real validator, stubbed services, DOM stub) | `npm test` | 105 tests pass |
+| Pure logic, host integration and browser-half DOM behaviour (real HTTP, real validator, stubbed services, DOM stub) | `npm test` | 139 tests pass |
 | Browser-half static checks (registration, i18n completeness, styles, skin legibility, three-way version sync, wire contract) | `npm run verify:client` | all pass |
 | Live client artifact (is the running DSH serving the current code?) | `npm run verify:live -- --token-file ~/path/to/dsh.log` | all pass, **including anchors on the host's node shapes** |
 | **Real browser rendering smoke** (CDP drives an already-open tab, read-only) | `npm run verify:ui` | all pass: the served bytes are the edited bytes, no empty placeholder left by a retired entry, the reply pencil sits in the platform action bar, a rolled-back row keeps its action bar, **every collapsed user message still shows the text that replaced it**, **that bubble sits above the time and the copy, in the order the platform draws a message**, **the rewriting pencil sits at the end of the surviving bar (confirmed live in the original session, the other session, and back again)**, **the reply pencil leads its bar, ahead of the copy (confirmed live)**, no `.dshet-floating` covers the revision text, and the entries survive a session round trip |
@@ -725,6 +742,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 - **The rollback is durable; the hiding is not.** Once written, the rollback permanently changes the model context. Hiding those rows in the transcript is this plugin's browser half. Uninstall the plugin and the old rows reappear - while the rollback in the model context still stands, because the replacement is an official event that outlives the plugin.
 - **The system prompt is never touched**: the window can never include surface node 0, and that node is never editable.
 - **Old sessions (v3-format logs) cannot be read under DSH 0.1.7**: the session reader answers `session-not-found` for them, so the plugin does not work in one at all (the visible symptom is no edit entry). Newly written sessions are v4 and work normally.
+- **Only the transcript's own copy button is taken over on a rewritten row.** The platform draws the same stale text in its other copy affordance - the **Trajectory view** (`dsh-client-ui-trajectory`) - which this release does not answer: copying a rewritten message there still hands over the pre-rewrite wording.
 
 ### Troubleshooting: the edit entry disappeared entirely
 

package/lib/client.js

@@ -34,13 +34,21 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.15'
+    const PLUGIN_VERSION = '0.2.17'
 
     // --- copy -----------------------------------------------------------------
 
     const zh = {
       'action.edit': '编辑这条消息',
       'action.edit-reply': '编辑这条回答',
+      // The platform's own words for its copy action, spelled here because the
+      // row's copy button is recognised BY them (see `nativeCopyButton`): the host
+      // labels that button through the shared `common` dictionary, and this is the
+      // same wording. Namespace keys shadow the shared ones, so these two keep the
+      // bundle's own key surface complete; the structural rule does not need them.
+      'copy': '复制',
+      'copied': '复制成功',
+      'action.copied': '复制成功',
       'editor.title': '编辑这条消息',
       'editor.title-reply': '编辑这条回答',
       'editor.placeholder': '改成你希望自己当时说的内容。保存后这条消息之后的轮次会从模型上下文中移除，改后的内容成为新的起点。',
@@ -78,6 +86,9 @@ window.__ModuleLoader__.load({
     const en = {
       'action.edit': 'Edit this message',
       'action.edit-reply': 'Edit this reply',
+      'copy': 'Copy',
+      'copied': 'Copied',
+      'action.copied': 'Copied',
       'editor.title': 'Edit this message',
       'editor.title-reply': 'Edit this reply',
       'editor.placeholder': 'Saving rolls the conversation back to just before this message and this turn runs again.',
@@ -190,6 +201,15 @@ window.__ModuleLoader__.load({
       // the platform's time / copy / delete buttons (and every other plugin's)
       // stay reachable, so only rows with nothing worth keeping go fully away.
       '[data-dshet-hidden="1"]:not([data-dshet-keep-actions]){display:none!important}',
+      // The one platform action on such a row that cannot answer for itself:
+      // copy hands over the text of the message the row was DRAWN for - the
+      // wording the user replaced, because the host draws no row for a
+      // replacement event. This half answers that press and draws the host's
+      // own "copied" moment on the same button (`takeOverRowCopy`): the icon
+      // is swapped for a check the way the host swaps it, for the same second.
+      '[data-dshet-copy-flash="1"]{position:relative}',
+      '[data-dshet-copy-flash="1"]>svg{opacity:0}',
+      '[data-dshet-copy-flash="1"]::after{content:"";position:absolute;left:50%;top:50%;width:7px;height:12px;margin:-7px 0 0 -4px;border:solid currentColor;border-width:0 1.5px 1.5px 0;transform:rotate(45deg)}',
       // One rounded container, the way the platform's own composer box is
       // built: the input is transparent and borderless inside it, the actions
       // sit at its bottom-right, and focus is shown on the container rather
@@ -893,6 +913,9 @@ window.__ModuleLoader__.load({
       const existing = ownRevisionBubble(row)
       if (revisionSeq === null || !hidden) {
         if (existing !== null) existing.remove()
+        // Nothing of ours stands in for this row any more: the row's own copy
+        // button answers for itself again.
+        releaseRowCopy(row)
         return true
       }
       // Only one bubble per row, ever: drop any other bubble that claims it
@@ -912,6 +935,7 @@ window.__ModuleLoader__.load({
       const text = entry && typeof entry.text === 'string' ? entry.text : ''
       if (text === '') {
         if (existing !== null) existing.remove()
+        releaseRowCopy(row)
         return node.kind !== 'user'
       }
       const bubble = existing === null ? cloneUserBubble(row) : existing
@@ -936,14 +960,21 @@ window.__ModuleLoader__.load({
           injectRowAction(row, editTarget, controller, t)
           removeRowAction(bubble)
           bubble.classList.remove('dshet-revision-action')
+          // The bar that survived still holds the host's own copy button, and it
+          // reads the message this row was drawn for - the wording the user just
+          // replaced. This row's text is the bubble above it, so the press is
+          // answered here (`takeOverRowCopy`).
+          takeOverRowCopy(row, text, t)
         } else {
           injectRowAction(bubble, editTarget, controller, t, { gutter: true })
           removeRowAction(row)
           bubble.classList.add('dshet-revision-action')
+          releaseRowCopy(row)
         }
       } else {
         removeRowAction(bubble)
         bubble.classList.remove('dshet-revision-action')
+        releaseRowCopy(row)
       }
       return true
     }
@@ -995,6 +1026,237 @@ window.__ModuleLoader__.load({
       return null
     }
 
+    // --- the rewritten row answers its own copy -------------------------------
+    //
+    // The platform's copy action hands over the text of the message it DREW the
+    // row for. A prompt this plugin rewrote in place never gets a row of its own:
+    // the host draws transcript rows for append-origin surface events only
+    // (`isAppendSurfaceEvent` in dsh-client-ui-chat), and a rewrite is a
+    // replacement, so the row that stands in for the message is the ORIGINAL one
+    // and still carries the wording the user replaced. Pressing copy on a
+    // rewritten prompt therefore pastes what the user was trying to get rid of:
+    // rewrite 回复1 into 回复2, press copy, paste 回复1.
+    //
+    // The button cannot be repaired from here - its text is read off the host's
+    // projection node, while the rewritten wording is the textContent of a bubble
+    // this half owns - and it must not be taken out either: the host owns that
+    // node and unmounts it through its own reconciler, and a bundle that goes
+    // away has to leave a working button behind, not a dead one. What this half
+    // CAN do is answer the press first: the listener is planted in the CAPTURE
+    // phase, the host listens for clicks at its root in the bubble phase, so this
+    // runs ahead of the host's handler and stops it, and the text it writes is
+    // the text this row actually shows.
+    //
+    // Everything the listener needs is read off the BUTTON when the press
+    // happens - the text, the label, the writer - never captured in the closure.
+    // A reloaded bundle finds the button by its marker, refreshes that state, and
+    // a listener the instance before it planted goes on working (the rule
+    // `wireAction` follows for the pencil).
+    const COPY_TEXT = 'dshetCopyText'
+    const COPY_FLASH = 'dshetCopyFlash'
+    const COPY_LABEL = 'dshetCopyLabel'
+    const COPY_OWN = 'dshetCopyOwn'
+    /** The live state of one press; a name no sibling plugin uses. */
+    const COPY_PRESS = 'dshetCopyPress'
+    const COPY_TIMER = 'dshetCopyTimer'
+    /** The host draws its own check for a second; this is the same second. */
+    const COPY_FEEDBACK_MS = 1000
+
+    /**
+     * A button another plugin put in this bar.
+     *
+     * Every injected action in this family carries its own namespace marker (the
+     * three sibling plugins do, by contract), and the host's own actions carry no
+     * `data-*` of their own at all. This plugin's four markers are excluded:
+     * they are written on the HOST's button, not on one of ours.
+     */
+    function pluginOwned(button) {
+      const data = button.dataset
+      if (data === undefined || data === null) return false
+      for (const key of Object.keys(data)) {
+        if (key === COPY_TEXT || key === COPY_FLASH || key === COPY_LABEL || key === COPY_OWN) continue
+        if (key !== '') return true
+      }
+      return false
+    }
+
+    /**
+     * The platform's own copy button in a row's action bar, or null when the bar
+     * holds none of its own to answer for.
+     *
+     * The host draws the clock, then the copy button, and gives a user row neither
+     * a branch action nor an extra strip - so the bar's FIRST button is the copy
+     * button. The CSS-module class the host's icons carry is deliberately not
+     * required: it is a build hash that can be renamed, and a rule that reads it
+     * would go quietly dead on the day it is (the pencil placement still matches
+     * that suffix, which is a different, visible contract). A sibling plugin's
+     * button is skipped: it carries its own namespace marker, and a sibling's is
+     * never this half's to answer for. A button this half already answers is
+     * found by ITS marker alone (I3), however the bar has been rebuilt around it.
+     */
+    function nativeCopyButton(row, t) {
+      if (row === null || row === undefined || typeof row.querySelector !== 'function') return null
+      const bar = row.querySelector('[class*="_actions"]')
+      if (bar === null || bar === undefined) return null
+      // The host's own wording for the two states of its copy button. It resolves
+      // through the same namespace -> shared `common` fallback the host's own
+      // lookup uses, so this names the button rather than guessing at it; a host
+      // that cannot resolve them simply falls through to the rule below.
+      const copy = typeof t === 'function' ? t('copy') : null
+      const copied = typeof t === 'function' ? t('copied') : null
+      let unclaimed = null
+      for (const child of bar.children) {
+        if (child.tagName !== 'BUTTON') continue
+        if (child.dataset !== undefined && child.dataset[COPY_OWN] === '1') return child
+        if (pluginOwned(child)) continue
+        const label = typeof child.getAttribute === 'function' ? child.getAttribute('aria-label') : null
+        if (typeof label === 'string' && label !== '' && (label === copy || label === copied)) return child
+        if (unclaimed === null) unclaimed = child
+      }
+      return unclaimed
+    }
+
+    /**
+     * Hand a rewritten row's copy press to this half.
+     *
+     * The button is left exactly as the host rendered it - not removed, not
+     * hidden, not disabled; only this half's own markers go on it. Without the
+     * host's own clipboard writer the button keeps the host's behaviour too: a
+     * takeover that cannot copy is worse than none.
+     */
+    function takeOverRowCopy(row, text, t) {
+      const button = nativeCopyButton(row, t)
+      if (button === null) return
+      const write = primitives !== null && primitives !== undefined && typeof primitives.writeClipboard === 'function'
+        ? primitives.writeClipboard
+        : null
+      if (write === null) return
+      if (button.dataset !== undefined && button.dataset[COPY_OWN] !== '1') {
+        button.dataset[COPY_OWN] = '1'
+        if (typeof button.addEventListener === 'function') {
+          // Capture: this runs ahead of the host's own click handling, which
+          // listens at the root and would write the message the row was drawn for.
+          // Stopping the event there is also what keeps that handler from running
+          // at all, so the host's own follow-up (its tooltip withdraw, its check)
+          // does not happen for this press - which is why the check is drawn here.
+          button.addEventListener('click', (event) => pressRowCopy(button, event), true)
+        }
+      }
+      if (button.dataset !== undefined) {
+        // The host's own wording, kept to give back: what the button said before
+        // this half drew its check over it.
+        if (button.dataset[COPY_LABEL] === undefined) {
+          const label = typeof button.getAttribute === 'function' ? button.getAttribute('aria-label') : null
+          if (typeof label === 'string' && label !== '') button.dataset[COPY_LABEL] = label
+        }
+        if (button.dataset[COPY_TEXT] !== text) button.dataset[COPY_TEXT] = text
+      }
+      button[COPY_PRESS] = { done: t('action.copied'), write }
+    }
+
+    /**
+     * The press itself.
+     *
+     * No text marker means the row is not (or no longer) a rewritten prompt, and
+     * the press is left completely alone: the host's own handler answers it, and a
+     * released row behaves like every other row.
+     */
+    function pressRowCopy(button, event) {
+      const data = button.dataset
+      if (data === undefined || typeof data[COPY_TEXT] !== 'string') return
+      if (event !== null && event !== undefined) {
+        if (typeof event.preventDefault === 'function') event.preventDefault()
+        if (typeof event.stopPropagation === 'function') event.stopPropagation()
+      }
+      // One copy per check, the way the host paces its own button.
+      if (data[COPY_FLASH] === '1') return
+      const press = button[COPY_PRESS]
+      if (press === null || press === undefined || typeof press.write !== 'function') return
+      let pending = null
+      try {
+        pending = press.write(data[COPY_TEXT])
+      } catch {
+        return
+      }
+      if (pending === null || pending === undefined || typeof pending.then !== 'function') return
+      pending.then(
+        (ok) => {
+          if (ok === true) flashRowCopy(button, press.done)
+        },
+        () => {},
+      )
+    }
+
+    /**
+     * The host's own "copied" moment, drawn on the button it belongs to.
+     *
+     * The host shows it by swapping its icon and its label. On this row its own
+     * React state never hears about the press, so this half draws the same thing
+     * from its stylesheet (`[data-dshet-copy-flash="1"]`) and gives the borrowed
+     * label back when the moment is over. Both are this half's own writes, and
+     * both are taken back on release (I4).
+     */
+    function flashRowCopy(button, done) {
+      const data = button.dataset
+      if (data === undefined) return
+      data[COPY_FLASH] = '1'
+      if (typeof done === 'string' && done !== '' && typeof button.setAttribute === 'function') {
+        button.setAttribute('aria-label', done)
+      }
+      if (button[COPY_TIMER] !== undefined && button[COPY_TIMER] !== null) {
+        if (typeof window.clearTimeout === 'function') window.clearTimeout(button[COPY_TIMER])
+      }
+      if (typeof window.setTimeout !== 'function') return
+      button[COPY_TIMER] = window.setTimeout(() => {
+        button[COPY_TIMER] = null
+        clearRowCopyFlash(button)
+      }, COPY_FEEDBACK_MS)
+    }
+
+    /**
+     * Take the check back.
+     *
+     * `data-dshet-copy-label` is what the host's own button said before this half
+     * drew its check on it; the host never wrote it, so giving it back is this
+     * half returning its own change (I4).
+     */
+    function clearRowCopyFlash(button) {
+      if (button[COPY_TIMER] !== undefined && button[COPY_TIMER] !== null) {
+        if (typeof window.clearTimeout === 'function') window.clearTimeout(button[COPY_TIMER])
+        button[COPY_TIMER] = null
+      }
+      const data = button.dataset
+      if (data === undefined) return
+      delete data[COPY_FLASH]
+      const label = data[COPY_LABEL]
+      if (typeof label === 'string' && label !== '' && typeof button.setAttribute === 'function') {
+        button.setAttribute('aria-label', label)
+      }
+    }
+
+    /** Hand one platform copy button back: nothing of ours is left WRITTEN on it. */
+    function releaseCopyButton(button) {
+      if (button === null || button === undefined || typeof button !== 'object') return
+      clearRowCopyFlash(button)
+      const data = button.dataset
+      if (data !== undefined) {
+        delete data[COPY_TEXT]
+        delete data[COPY_LABEL]
+      }
+      button[COPY_PRESS] = undefined
+      // `data-dshet-copy-own` stays, and so does the listener: neither claims
+      // anything about the message any more, and that marker is what stops a
+      // reloaded bundle from planting a second listener on the same button. A
+      // press with no text marker returns above and reaches the host's own
+      // handler - exactly the behaviour the row had before this plugin saw it.
+    }
+
+    /** The copy handover of a row, wherever the last pass left it. */
+    function releaseRowCopy(row) {
+      const button = nativeCopyButton(row)
+      if (button !== null) releaseCopyButton(button)
+    }
+
     // The message a chain of rewrites ends at.
     //
     // Rewriting the same message twice lands two replacements: 8 -> 19 for the
@@ -1894,6 +2156,11 @@ window.__ModuleLoader__.load({
       //    markers are this plugin's own writes, so this is its own state - and
       //    only its own: the restore path asks the attribution guard first (I4).
       each('[data-dshet-hidden="1"]', (row) => setRowHidden(row, false))
+      // A row's copy button was answering for this half; that handover is this
+      // half's own write on a HOST node and goes back the same way (I4). The
+      // button itself stays where the host owns it - it simply copies its own
+      // message again, through the host's handler.
+      each('[data-dshet-copy-text]', (button) => releaseCopyButton(button))
       each('[data-dshet-collapsed="1"]', (child) => {
         child.style.display = ''
         delete child.dataset.dshetCollapsed

package/lib/index.js

@@ -57,7 +57,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.2.15'
+export const PLUGIN_VERSION = '0.2.17'
 
 // 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
@@ -248,16 +248,34 @@ export function messageIdOf(event) {
  * @param event - raw session event.
  * @returns true for a human prompt.
  */
+export function isEditCarrier(source) {
+  if (!source || typeof source !== 'object') return false
+  // Current shape. `editedBy` is what identifies a carrier now; the prompt carrier
+  // deliberately keeps `kind: 'user'` (see buildCarrier) so the platform still reads
+  // it as the human prompt, and the silent reply carrier keeps a producer-owned kind.
+  if (source.editedBy === PLUGIN_ID) return true
+  // Historical shapes, kept so ledgers and editability stay correct over logs
+  // written by earlier releases: the producer-owned kind without `editedBy`, and
+  // the session-format v3 `{ kind: 'plugin', plugin }`.
+  if (source.kind === `plugin:${PLUGIN_ID}`) return true
+  return source.kind === 'plugin' && source.plugin === PLUGIN_ID
+}
+
 export function isHumanPrompt(event) {
   if (!event || event.type !== 'user/message') return false
   const data = event.data
   if (!data || !data.source) return false
+  // The platform's own test, and the one every consumer applies (`turn-outline`,
+  // the Trajectory view, `ui-chat`, the inbox steering filter, `lastPromptAt`): a
+  // human prompt is a `user/message` whose source kind is `'user'`. A message this
+  // plugin rewrote stands in a human's place and keeps that kind, so it stays
+  // editable (edit it again). Matching a plugin-owned kind instead is what made
+  // the rewrite invisible to the turn outline - the round lost its prompt.
   if (data.source.kind === 'user') return true
-  // A message this plugin rewrote stands in a human's place: it is the wording
-  // the user is asking with now, so it stays editable (edit it again) even though
-  // its source records that the plugin wrote it. The distinct kind also keeps the
-  // platform from treating it as fresh input to answer.
-  return data.source.kind === `plugin:${PLUGIN_ID}` && data.source.editedBy === PLUGIN_ID
+  // Carriers written before that fix carry a producer-owned kind. Same message -
+  // a `user/message` this plugin rewrote - so it must stay editable, or upgrading
+  // would silently make every earlier edit un-editable.
+  return isEditCarrier(data.source)
 }
 
 /**
@@ -304,9 +322,10 @@ export function readMessageText(event) {
 /**
  * Rebuild this plugin's rollback ledger from the log alone.
  *
- * Every rollback is one replacement event whose message source is
- * `{ kind: 'plugin', plugin: 'dsh-edit-turn' }`. A replacement landed by any
- * other producer - compaction, for instance - is ignored.
+ * Every rollback is one replacement event whose message source carries this
+ * plugin's marker (`{ editedBy: 'dsh-edit-turn' }`; see {@link isEditCarrier}).
+ * A replacement landed by any other producer - compaction, for instance - is
+ * ignored.
  *
  * @param events - complete contiguous raw event log.
  * @returns `{ hidden, edits }`: one hidden entry per shadowed seq, and one
@@ -322,7 +341,7 @@ export function rollbackLedger(events) {
     const event = bySeq.get(replacement.seq)
     const data = event && event.data
     const source = data && (data.source || (data.message && data.message.source))
-    if (!(source && (source.kind === `plugin:${PLUGIN_ID}` || (source.kind === 'plugin' && source.plugin === PLUGIN_ID)))) continue
+    if (!isEditCarrier(source)) continue
     for (const seq of replacement.shadowed) {
       const turn = turnOf.get(seq)
       hidden.push({ seq, turn: typeof turn === 'number' ? turn : null, replacement: replacement.seq })
@@ -789,7 +808,19 @@ export function buildCarrier(plan, lastTurn, config) {
       id: randomUUID(),
       role: 'user',
       content: [{ type: 'text', text: config.markerText }],
-      source: { kind: `plugin:${PLUGIN_ID}`, editedBy: PLUGIN_ID },
+      // `kind: 'user'`, NOT a plugin-owned kind. This carrier stands in a human's
+      // place - it IS the wording the user is asking with now - and the platform
+      // owns that judgement: a human prompt is exactly a `user/message` whose
+      // `source.kind` is `'user'`. Writing anything else here made the turn's
+      // prompt unrecognisable to every consumer that tests it -
+      // `dsh-session-turn-outline` (the turn rail and the Trajectory view),
+      // `dsh-client-ui-trajectory`, `dsh-client-ui-chat`, the inbox steering
+      // filter, and `lastPromptAt` on the session list - so an edited turn
+      // showed no prompt at all and `turnOutline` reported `prompt: ""`. The
+      // format's producer-owned kind (`plugin:<id>`) is for messages a plugin
+      // authors in its own voice; a prompt it merely rewrote is not one.
+      // `editedBy` below carries the provenance that `kind` used to.
+      source: { kind: 'user', editedBy: PLUGIN_ID },
     },
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Edit any user turn in DeepSeek Harness and re-run it: an inline editor on the message row rolls the conversation back to just before that turn through the official surface-replace contract, then re-prompts the agent with the revised text. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",