dsh-edit-turn 0.2.12 → 0.2.15

package/README.md

@@ -213,6 +213,26 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**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` 推到该轮号**。
+- **形状与降级**：`syncLoopTurn(agent, maxTurn)` 只看 `phase.kind === 'idle'` 且 `phase.lastTurn` 为数字时才动，否则 `'unavailable'` 什么也不碰（冷会话、循环不在场都走这条），并把结果以 `loopTurn` 写进 apply 响应、把 `unavailable` 记进 `/dsh-edit-turn/debug` 的请求环（字段刻意不叫 `code:`——静态检查会把它当宿主错误码去要文案）。
+- 新增/改写 host 测试 2 个：命中的循环被推过消耗掉的轮号（连续两次编辑，计数器只向前），够不着的循环原样留着并留诊断；加单测 1 个（守卫：running / 缺字段 / null 都返回 unavailable）。129 单测 / 80 契约 / 静态 exit0 / verify:live / verify:ui 全绿。
+
+**0.2.14** —— 修「重新 apply 时上一次注入的节点不清理 → 同一条消息行上堆出多个宿主」（互操作契约 I3 / §5）。只修 Bug，交互语义不变。
+
+- **修复：重新 apply（HMR / 现场重载 / 插件开关 / bundle 组重载）会在同一行里再种一个编辑宿主，而不是复用上一次那个**。旧宿主的身份记在模块实例的 WeakMap 里，实例一换就认不出；于是每 apply 一次，那条操作条里就多一个「编辑这条消息」的笔。真机 CDP 探针实测同一 strip 里 `dshet-action-host` 多达 **7 个**、children 一度到 17（页面重载后回到 1、stripKids = 5），用户看到的是「一行上出现 3 个重跑按钮」。现在**每个注入节点都带命名空间属性**（宿主 `data-dshet-action-host="1"`、浮层根 `data-dshet-layer="1"`、编辑框 `data-dshet-editor="1"`、替代气泡 `data-dshet-revision="1"`），注入前先按属性在行内查一次、查到就**复用**——并且把它重新指到**当前**控制器（激活函数挂在按钮元素上、按下时才读，不再是上次那份捕获了旧闭包的监听；否则复用的笔点开的是已退休的控制器，表现就是「点了没反应」）。每趟 DOM pass 结束还会清掉「本次实例没有认领的」同命名空间宿主，正是那 7 个的直接来源；扫描只认自己的命名空间，兄弟插件的按钮永远不在候选里（I3）。
+- **修复：卸载时不再把自己的注入节点留在页面上**。fiber dispose（`ctx.effect` 的清理）现在按属性选择器**全局**扫掉本插件的注入节点（宿主 / 替代气泡 / 编辑框 / 浮层根），并把**只属于自己**的隐藏交还给宿主行（`data-dshet-hidden` / `data-dshet-collapsed` / 折叠中途的内联样式），恢复可见前照旧先问归属（I4）；React 自己渲染的节点（提示条、回答动作条里那支笔）**不扫**——从 React 手里抽走节点会让它在卸载时抛错。
+- **English**: re-applying the bundle (HMR, a live reload, a plugin toggle) over the same page no longer plants a second edit-action host on the row - every injected node now carries a namespace attribute, an existing host is looked up in the row and reused (with its activation re-pointed at the controller that is mounted now, read off the button at press time), any host this apply instance did not claim is swept at the end of the pass, and disposing the fiber removes every node this plugin injected (hosts, revision bubbles, the editor and its layer root) while handing back only its own row/child hiding - React-owned nodes are deliberately left to the reconciler.
+- 本版：`npm test` 126/126、`npm run verify:contract` 80/80、`npm run verify:client` 157/157 全绿（exit 0，`npm run check` 连跑两次同结果）；新增 5 条 DOM 用例与 12 条静态检查；5 条新用例已用「把三处修复改回旧写法」验证必红——旧代码下那条 strip 里的宿主数正好是 **7**（与探针一致），卸载后宿主数仍是 1（等于不清理）。
+
+**0.2.13** —— 隐藏归因（互操作契约 I4）+ 兄弟探测硬化（I5）。只修 Bug，交互语义不变。
+
+- **修复：别人隐藏的行，本插件不再替它显示出来**。回退的「恢复可见」分支无条件把 `row.style.display` 清成 `''`——那一行若正被 **dsh-delete-turn**（`data-dshdt-hidden`）或 **dsh-rerun-turn**（`data-dsrr-hidden`）按归属属性隐藏着，本插件一恢复就把别人的隐藏一并抹掉（行"复活"）。现在按契约 §4 在本地拷入 `foreignHideOn(row,'dshet')`：恢复前先确认没有别的归属属性，有则**保持 `display:none`**，只交还本插件自己那份隐藏。同理，折叠子节点时只有**本插件亲手写下**的 `display:none` 才打 `data-dshet-collapsed` 标记，恢复时也不会把别的插件留下的 `none` 重新显示出来。
+- **修复：兄弟探测的过期答案不再覆盖新答案**（探测令牌，编辑器连开两次时不再闪一下又消失）；`fetch` 抛错仍归入「缺席」且不打印任何日志（I5），探测结果为 `unknown` 时依旧不渲染重跑按钮。
+- **English**: rows another plugin is keeping hidden are no longer un-hidden by this plugin's restore pass (`foreignHideOn(row, 'dshet')`, contract §4), a `display:none` this plugin did not write is no longer claimed by the collapse marker, and a sibling-probe answer older than the newest probe can no longer take the re-run button back out; a failed probe stays silent and absent.
+- 本版：`npm test` 121/121、`npm run verify:contract` 80/80、`npm run verify:client` 145/145 全绿（exit 0）；新增 7 条 DOM 用例与 5 条静态检查，三条新用例已用「改回旧代码」验证必红。
+
 **0.2.12** —— 编辑器里的「重跑」（转发给 dsh-rerun-turn），并删除旧的 `rerun` 配置。
 
 - **新增：「重跑」按钮（提示词编辑专用）**。装了姊妹插件 **dsh-rerun-turn** 时，取消/保存 旁多一个「重跑」：先走本插件的保存（就地替换、不花模型调用），紧接着调用它的 `POST /dsh-rerun-turn/apply { sessionId, seq: 该轮作答 }`——它按表面现在显示的提示词（你改后的文本）重新生成，并把后续轮次逐事件重放回来。探测方式与它的加载器探针一致（不带 sessionId 请求它的 `/state`：400=装着、404=没装），**没装就没有这个按钮**（例如桌面版没装时）。回答编辑不加这个按钮——回答动作条里本来就有它自己的 ↻。**它的 apply 不接受改写文本，所以顺序永远是先保存、后重跑**；该轮没有可重跑的作答、或它拒绝（`not-rerunnable`/`already-retired`/`busy`/`rerunning`…）时，按错误码提示，不影响已经落地的保存。

package/lib/client.js

@@ -34,7 +34,7 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.12'
+    const PLUGIN_VERSION = '0.2.15'
 
     // --- copy -----------------------------------------------------------------
 
@@ -286,6 +286,9 @@ window.__ModuleLoader__.load({
         this.clearTimer = null
         this.pendingRerun = false
         this.siblingRerun = 'unknown'
+        // Bumped on every probe: an answer older than the newest probe is stale
+        // and must not move the button.
+        this.probeToken = 0
         this.confirming = false
         this.noticeTimer = null
         this.view = Object.freeze({
@@ -432,13 +435,20 @@ window.__ModuleLoader__.load({
       // does not exist. A change is published - the editor's marker carries it,
       // so the button appears (or never does).
       async probeSiblingRerun() {
+        const token = (this.probeToken += 1)
         let status = 0
         try {
           const response = await fetch(`${RERUN_PREFIX}/state`, { headers: { accept: 'application/json' } })
           status = response.status
         } catch {
+          // A sibling that is not mounted is not an error (I5): a rejected
+          // fetch, a timeout and a 404 all land in 'absent', and none of them
+          // logs anything.
           status = 0
         }
+        // Two opens before the first answer arrived: the slower probe used to
+        // land second and take the button back out. Only the newest speaks.
+        if (token !== this.probeToken) return
         const next = status === 400 || status === 405 ? 'present' : 'absent'
         this.siblingRerun = next
         if (this.view.siblingRerun !== next) this.publish({ siblingRerun: next })
@@ -736,6 +746,132 @@ window.__ModuleLoader__.load({
 
     const rowActions = new WeakMap()
 
+    // --- injected-node namespace ----------------------------------------------
+    //
+    // The host reloads this bundle in place: a new module instance with fresh
+    // closures, a fresh WeakMap and a fresh editor layer, over the DOM the
+    // previous instance left behind. Nothing in an instance can recognise its
+    // predecessor's nodes by identity, so every node this half injects carries
+    // its namespace in an attribute as well as in its class (contract I3): the
+    // attribute is what a reload looks for (reuse it, never plant a second) and
+    // what a real unload sweeps away. The class forms stay as fallbacks - a
+    // bundle older than this one injected the same nodes with the class alone.
+    const HOST_ATTR = 'dshetActionHost'
+    const LAYER_ATTR = 'dshetLayer'
+    const EDITOR_ATTR = 'dshetEditor'
+    const HOST_SELECTOR = '[data-dshet-action-host="1"],.dshet-action-host'
+    const LAYER_SELECTOR = '[data-dshet-layer="1"],.dshet-layer'
+    // The live activation of an injected action, kept on the button element
+    // itself: see `wireAction`.
+    const ACTIVATE = 'dshetActivate'
+    // Everything this half creates itself. The React-owned nodes are NOT in here
+    // on purpose (the notice banner, the reply entry in the assistant-actions
+    // strip): the host unmounts those through its own reconciler, and pulling a
+    // node out from under React makes it throw on the way out.
+    const OWN_NODE_SELECTOR = [
+      HOST_SELECTOR,
+      LAYER_SELECTOR,
+      '[data-dshet-editor="1"],.dshet-editor',
+      '[data-dshet-revision="1"],.dshet-revision',
+    ].join(',')
+
+    // The action hosts this module instance stands behind. A host carrying the
+    // namespace that no pass of this instance claimed cannot be positioned or
+    // updated by anyone: it is a leftover of an apply that is gone, and
+    // `dropUnclaimedHosts` takes it out.
+    const liveHosts = new WeakSet()
+
+    /** Does this node still hang in a tree? A parentless host is one nobody can see. */
+    function hasParent(node) {
+      return node !== null && node !== undefined && node.parentElement !== null && node.parentElement !== undefined
+    }
+
+    /** Is this one of our action hosts - by namespace attribute, or by class? */
+    function isActionHost(node) {
+      if (node === null || node === undefined) return false
+      const className = typeof node.className === 'string' ? node.className : ''
+      if (/(^|\s)dshet-action-host(\s|$)/.test(className)) return true
+      if (typeof node.matches === 'function') {
+        try {
+          return node.matches(HOST_SELECTOR) === true
+        } catch {
+          return false
+        }
+      }
+      return false
+    }
+
+    /** Every action host of ours inside `scope`, the scope itself included. */
+    function actionHostsIn(scope) {
+      const out = []
+      if (scope === null || scope === undefined) return out
+      if (isActionHost(scope)) out.push(scope)
+      if (typeof scope.querySelectorAll === 'function') {
+        for (const node of scope.querySelectorAll(HOST_SELECTOR)) {
+          if (!out.includes(node)) out.push(node)
+        }
+      }
+      return out
+    }
+
+    /** The button inside an injected host, wherever a previous apply left it. */
+    function actionButtonIn(host) {
+      for (const child of host.children) {
+        const className = typeof child.className === 'string' ? child.className : ''
+        if (child.tagName === 'BUTTON' || /(^|\s)dshet-action(\s|$)/.test(className)) return child
+      }
+      return null
+    }
+
+    function createActionHost() {
+      const host = document.createElement('span')
+      host.className = 'dshet-action-host'
+      host.dataset[HOST_ATTR] = '1'
+      return host
+    }
+
+    function createActionButton() {
+      const button = document.createElement('button')
+      button.type = 'button'
+      button.className = 'dshet-action dshet-row-action'
+      button.innerHTML = ICON_MARKUP
+      return button
+    }
+
+    /**
+     * Wire the press/click pair onto an injected action.
+     *
+     * The action itself is NOT captured here: it is read off the button at press
+     * time (`ACTIVATE`). A reloaded bundle reuses the very node the retired one
+     * injected - that is what the namespace is for - and it wires that node
+     * again, so the handler has to reach the controller that is mounted NOW.
+     * A captured closure would open the retired controller, which does nothing
+     * at all and reads exactly like a dead pencil.
+     */
+    function wireAction(button) {
+      pressable(button, () => {
+        const activate = button[ACTIVATE]
+        if (typeof activate === 'function') activate()
+      })
+    }
+
+    /** The pencil host a previous apply injected into this row, if there is one (I3). */
+    function adoptActionHost(row) {
+      const hosts = actionHostsIn(row)
+      if (hosts.length === 0) return null
+      // The first one wins: a second host in the same row is a ghost of an
+      // earlier apply, and the sweep at the end of this pass removes it.
+      const host = hosts[0]
+      if (host.dataset !== undefined && host.dataset[HOST_ATTR] !== '1') host.dataset[HOST_ATTR] = '1'
+      let button = actionButtonIn(host)
+      if (button === null) {
+        button = createActionButton()
+        host.appendChild(button)
+      }
+      wireAction(button)
+      return { host, button, target: null }
+    }
+
     // Show a rewritten prompt where its original row is.
     //
     // The bubble is cloned from a real user bubble's classes at runtime - the
@@ -779,7 +915,6 @@ window.__ModuleLoader__.load({
         return node.kind !== 'user'
       }
       const bubble = existing === null ? cloneUserBubble(row) : existing
-      if (existing === null) bubble.dataset.dshetRevision = '1'
       {
         const key = row.getAttribute('data-chat-flow-key')
         if (typeof key === 'string' && key !== '' && bubble.dataset[REVISION_FOR] !== key) {
@@ -823,6 +958,10 @@ window.__ModuleLoader__.load({
     function cloneUserBubble(row) {
       const bubble = document.createElement('div')
       bubble.className = 'dshet-revision'
+      // Namespace attribute as well as the class: a reloaded bundle finds this
+      // bubble by attribute (it has no memory of the node), and an unload sweeps
+      // it by the same selector.
+      bubble.dataset.dshetRevision = '1'
       if (row !== null && row !== undefined) {
         const key = row.getAttribute('data-chat-flow-key')
         if (typeof key === 'string' && key !== '') bubble.dataset[REVISION_FOR] = key
@@ -938,8 +1077,13 @@ window.__ModuleLoader__.load({
           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.
-            if (child.style.display !== 'none') child.style.display = 'none'
-            if (child.dataset.dshetCollapsed !== '1') child.dataset.dshetCollapsed = '1'
+            // The marker is written only for a `none` this plugin wrote (I4):
+            // a child another plugin had already displayed away is left
+            // untouched, so the restore pass cannot take that hiding back out.
+            if (child.style.display !== 'none') {
+              child.style.display = 'none'
+              if (child.dataset.dshetCollapsed !== '1') child.dataset.dshetCollapsed = '1'
+            }
           } else if (child.dataset.dshetCollapsed === '1') {
             child.style.display = ''
             delete child.dataset.dshetCollapsed
@@ -950,6 +1094,25 @@ window.__ModuleLoader__.load({
       return true
     }
 
+    // Attribution for the hiding below (contract §4). Another plugin writes its
+    // own marker on a row it displayed away (delete-turn 'dshdt', rerun-turn
+    // 'dsrr'); this half resets `display` for its OWN hide only, and a row
+    // another plugin is keeping away stays away.
+    const HIDE_OWNERS = [
+      ['dshdt', 'data-dshdt-hidden', 'dshdtHidden'],
+      ['dshet', 'data-dshet-hidden', 'dshetHidden'],
+      ['dsrr', 'data-dsrr-hidden', 'dsrrHidden'],
+    ]
+    /** Is anyone but `own` claiming a hide on this row? */
+    function foreignHideOn(row, own) {
+      for (const [key, attr, prop] of HIDE_OWNERS) {
+        if (key === own) continue
+        if (row.dataset?.[prop] === '1') return true
+        if (typeof row.hasAttribute === 'function' && row.hasAttribute(attr)) return true
+      }
+      return false
+    }
+
     function setRowHidden(row, hide, animate) {
       // A turn tail is not a message row. It is the strip a turn's end renders
       // (duration, usage, actions); when the turn behind it is rolled back the
@@ -1000,7 +1163,10 @@ window.__ModuleLoader__.load({
       delete row.dataset.dshetHidden
       if (row.dataset.dshetKeepActions === '1') delete row.dataset.dshetKeepActions
       row.classList.remove('dshet-collapsing')
-      row.style.display = ''
+      // I4: dropping our marker ends OUR hide. `display` is only ours to clear
+      // while no other plugin's hide marker stands - a row a sibling displayed
+      // away stays away, whatever this half would prefer.
+      row.style.display = foreignHideOn(row, 'dshet') ? 'none' : ''
       row.style.height = ''
       row.style.opacity = ''
       row.style.marginTop = ''
@@ -1012,6 +1178,7 @@ window.__ModuleLoader__.load({
     function removeRowAction(row) {
       const entry = rowActions.get(row)
       if (!entry) return
+      liveHosts.delete(entry.host)
       entry.host.remove()
       rowActions.delete(row)
     }
@@ -1019,28 +1186,47 @@ window.__ModuleLoader__.load({
     function injectRowAction(row, target, controller, t, options = {}) {
       const label = t(target.mode === 'reply' ? 'action.edit-reply' : 'action.edit')
       let entry = rowActions.get(row)
-      if (!entry) {
-        const host = document.createElement('span')
-        host.className = 'dshet-action-host'
-        const button = document.createElement('button')
-        button.type = 'button'
-        button.className = 'dshet-action dshet-row-action'
-        button.innerHTML = ICON_MARKUP
+      // An entry whose host lost its parent is not an entry any more: another
+      // apply swept the node away (or the host took it out with the container it
+      // was in), and a pass that only repositions it would leave this row with
+      // no pencil at all.
+      if (entry !== undefined && !hasParent(entry.host)) {
+        rowActions.delete(row)
+        entry = undefined
+      }
+      // I3: a host a previous apply injected into this row is REUSED, never
+      // doubled. The WeakMap cannot find it - a reloaded bundle starts with an
+      // empty one - so the namespace attribute is what does.
+      if (entry === undefined) {
+        const adopted = adoptActionHost(row)
+        if (adopted !== null) entry = adopted
+      }
+      if (entry === undefined) {
+        const host = createActionHost()
+        const button = createActionButton()
         // The marker goes on the BUTTON, not only on its wrapper: the pass that
         // looks for the official strip's entry queries buttons, so a marker one
         // level up made this pencil look like the strip's own and it deleted
         // itself - then the next pass put it back, which reads as flicker.
-        if (options.fallback === true) button.dataset.dshetFallback = '1'
         host.appendChild(button)
         entry = { host, button, target }
-        // Wired once, and the action reads the CURRENT target off the entry: the
-        // pass runs again on every snapshot, and re-wiring would reset the
-        // press guard between a pointerdown and the click it swallows.
-        pressable(button, () => controller.open(entry.target))
+        // The action reads the CURRENT target off the entry and the CURRENT
+        // controller off the button, so re-wiring on a later apply is harmless
+        // and a reloaded bundle can take this very node over.
+        wireAction(button)
         rowActions.set(row, entry)
       }
       entry.target = target
       const { host, button } = entry
+      // The fallback marker mirrors the placement chosen below: a host adopted
+      // from a gutter placement must not keep claiming one it no longer has.
+      if (options.fallback === true) {
+        if (button.dataset.dshetFallback !== '1') button.dataset.dshetFallback = '1'
+      } else if (button.dataset !== undefined && button.dataset.dshetFallback !== undefined) {
+        delete button.dataset.dshetFallback
+      }
+      button[ACTIVATE] = () => controller.open(entry.target)
+      liveHosts.add(host)
       if (button.getAttribute('aria-label') !== label) {
         button.setAttribute('aria-label', label)
         button.setAttribute('title', label)
@@ -1078,6 +1264,37 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /**
+     * One pencil per row, however often the bundle is applied over the same DOM.
+     *
+     * Every pass registers the host it stands behind in `liveHosts`. A host that
+     * carries this plugin's namespace and was claimed by NO pass of this
+     * instance cannot be positioned or updated by anyone: it is the leftover of
+     * an apply that is gone (a reload, a plugin toggle, a bundle-group swap),
+     * and left alone the bar collects one more of them per apply - the observed
+     * report was seven action hosts and seventeen children in a single strip,
+     * which the user reads as three re-run buttons on one row. Only nodes
+     * carrying this plugin's own namespace are ever considered (I3).
+     *
+     * The DOM pass runs on every snapshot, so a ghost is taken out on the first
+     * pass after the reload that produced it.
+     */
+    function dropUnclaimedHosts() {
+      if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return
+      let hosts = []
+      try {
+        hosts = document.querySelectorAll(HOST_SELECTOR)
+      } catch {
+        return
+      }
+      for (const host of hosts) {
+        if (liveHosts.has(host)) continue
+        try {
+          host.remove()
+        } catch {}
+      }
+    }
+
     // The platform's own action icons all carry a hashed class ending in
     // `_action`; the clock, the usage pill and anything this plugin adds do not
     // (ours are hyphenated). Matching that suffix avoids CSS-module hashes
@@ -1109,12 +1326,32 @@ window.__ModuleLoader__.load({
     let editorLayer = null
     function ensureEditorLayer() {
       if (editorLayer !== null && editorLayer.isConnected === true) return editorLayer
+      // A reloaded bundle starts with no layer of its own; the one the previous
+      // instance left is the same node doing the same job, so it is adopted
+      // rather than doubled (I3). The instance that left it takes it out with
+      // its own sweep when it is disposed.
+      const existing = ownLayer()
+      if (existing !== null && existing.isConnected !== false) {
+        editorLayer = existing
+        return editorLayer
+      }
       editorLayer = document.createElement('div')
       editorLayer.className = 'dshet-layer'
+      editorLayer.dataset[LAYER_ATTR] = '1'
       document.body.appendChild(editorLayer)
       return editorLayer
     }
 
+    /** The editor layer a previous apply left on the page, if there is one. */
+    function ownLayer() {
+      if (typeof document === 'undefined' || typeof document.querySelector !== 'function') return null
+      try {
+        return document.querySelector(LAYER_SELECTOR)
+      } catch {
+        return null
+      }
+    }
+
     // Put the box under the row it belongs to: same width, just below its lower
     // edge. Called on render and whenever the page scrolls or resizes, since
     // the layer is fixed to the viewport.
@@ -1233,6 +1470,7 @@ window.__ModuleLoader__.load({
       clearEditor()
       const box = document.createElement('div')
       box.className = 'dshet-editor'
+      box.dataset[EDITOR_ATTR] = '1'
       box.dataset.dshetFor = marker
 
       const area = document.createElement('textarea')
@@ -1442,6 +1680,10 @@ window.__ModuleLoader__.load({
         controller.editorBox = null
         controller.editorRow = null
       }
+      // Whatever of ours no row of this pass claimed is a ghost of an earlier
+      // apply: the host rebuilt the row under it, or the bundle was reloaded
+      // over it. Contract §5 - a button nobody can update must not pile up.
+      dropUnclaimedHosts()
     }
 
     // A snapshot this entry can read, or null when the controller cannot be
@@ -1617,6 +1859,65 @@ window.__ModuleLoader__.load({
       })
     }
 
+    // --- unload -----------------------------------------------------------------
+
+    /**
+     * Take back everything this half put on the page.
+     *
+     * Runs when the plugin is disposed - a reload, a toggle, a bundle-group swap
+     * - and it works by NAMESPACE, never by identity: the WeakMap and the layer
+     * reference die with the module instance, the attributes on the nodes do
+     * not, and the instance that replaces this one starts with no memory of them
+     * at all. That is exactly why a reload used to leave a second pencil (and a
+     * third, and a fourth) in the same bar.
+     *
+     * Only nodes this plugin created are removed, and only state this plugin
+     * wrote is taken back (I3, I4): a row another plugin is keeping away stays
+     * away, and the host's own buttons never move.
+     */
+    function releaseInjectedNodes() {
+      if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return
+      const each = (selector, act) => {
+        let nodes = []
+        try {
+          nodes = document.querySelectorAll(selector)
+        } catch {
+          return
+        }
+        for (const node of nodes) {
+          try {
+            act(node)
+          } catch {}
+        }
+      }
+      // 1. The platform's own rows go back to how this half found them. These
+      //    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))
+      each('[data-dshet-collapsed="1"]', (child) => {
+        child.style.display = ''
+        delete child.dataset.dshetCollapsed
+      })
+      // A row caught mid-collapse keeps the inline height and opacity this half
+      // wrote, and nothing after this would ever clear them.
+      each('.dshet-collapsing', (row) => {
+        row.classList.remove('dshet-collapsing')
+        row.style.height = ''
+        row.style.opacity = ''
+        row.style.marginTop = ''
+        row.style.marginBottom = ''
+        row.style.paddingTop = ''
+        row.style.paddingBottom = ''
+      })
+      // 2. Every node this half created goes with it: the injected pencils, the
+      //    bubbles standing in for rewritten prompts, the editor and the layer
+      //    it is hosted on. React's own nodes are deliberately not in the
+      //    selector - the host unmounts those, and pulling one out from under
+      //    React makes it throw on the way out.
+      each(OWN_NODE_SELECTOR, (node) => node.remove())
+      editorLayer = null
+    }
+
     // --- plugin ---------------------------------------------------------------
 
     function apply(ctx) {
@@ -1635,6 +1936,11 @@ window.__ModuleLoader__.load({
         () => () => {
           for (const controller of controllers.values()) controller.dispose()
           controllers.clear()
+          // The DOM this half injected is not owned by the controllers: it
+          // outlives them, and the next apply has no way to find it except by
+          // namespace. An unload that does not take it out is what left one more
+          // pencil in the bar on every reload (I3, contract §5).
+          releaseInjectedNodes()
         },
         'dsh-edit-turn: per-session controllers',
       )

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.12'
+export const PLUGIN_VERSION = '0.2.15'
 
 // 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
@@ -574,6 +574,23 @@ function findLiveSession(ctx, sessionId) {
 // Resolve the live Session that owns the append. An already-open session is
 // used directly; a cold one is resumed through the official controller, which
 // is exactly what the web UI does when the user opens it.
+/**
+ * The live agent whose loop owns this session's turn counter, when one exists.
+ * @param ctx - plugin context.
+ * @param sessionId - session to resolve.
+ * @returns the agent, or undefined (cold session, or no controller mounted).
+ */
+async function resolveLoopAgent(ctx, sessionId) {
+  const controller = ctx.get('sessionController')
+  if (!controller || typeof controller.resolveAgent !== 'function') return undefined
+  try {
+    const result = await controller.resolveAgent(sessionId)
+    return result && result.agent ? result.agent : undefined
+  } catch {
+    return undefined
+  }
+}
+
 async function resolveSession(ctx, sessionId) {
   const live = findLiveSession(ctx, sessionId)
   if (live) return live
@@ -589,6 +606,44 @@ async function resolveSession(ctx, sessionId) {
   return undefined
 }
 
+/**
+ * Make the live agent loop agree with a turn this plugin opened in the log.
+ *
+ * The loop keeps its own counter in an idle-phase field (`phase.lastTurn`): it
+ * is seeded when the loop is constructed from the projection and advanced only
+ * by turns the loop itself opens. A reply edit has to open a turn - the read
+ * path admits an `assistant/message` only inside an open turn and step - so
+ * afterwards that field still names the turn this plugin consumed, and the
+ * loop's next run would open the same number. That collides: both turn/start
+ * events claim one number and the log fails its next load
+ * (`turn/start does not open the expected turn`), which is the corruption this
+ * plugin already shipped once and repaired.
+ *
+ * The shape guard is deliberate and the failure is soft: if the loop is not
+ * idle, or its shape is not what this expects, nothing is touched and the
+ * caller records why. The sibling plugin dsh-rerun-turn solves the same
+ * problem the same way (`syncLoopTurn`); there is no official seam for it.
+ *
+ * @param agent - the live loop agent, when one exists.
+ * @param maxTurn - the highest turn now in the log.
+ * @returns `'synced' | 'already-current' | 'unavailable'`.
+ */
+export function syncLoopTurn(agent, maxTurn) {
+  try {
+    const phase = agent && agent.phase
+    if (!phase || typeof phase !== 'object' || phase.kind !== 'idle' || typeof phase.lastTurn !== 'number') {
+      return 'unavailable'
+    }
+    if (maxTurn > phase.lastTurn) {
+      phase.lastTurn = maxTurn
+      return 'synced'
+    }
+    return 'already-current'
+  } catch {
+    return 'unavailable'
+  }
+}
+
 function eventsFromLive(session) {
   if (session && typeof session.snapshotEvents === 'function') {
     try {
@@ -885,11 +940,25 @@ async function applyEdit(ctx, sessionId, body, config) {
       }
     }
     const corrected = await flushSession(ctx, session)
+    // The synthetic turn this edit opened is invisible to the live loop's own
+    // counter; without the sync its next run reuses that number and the log
+    // fails its next load. Only a reply edit opens a turn - a prompt edit does
+    // not, and needs nothing.
+    const loopAgent = await resolveLoopAgent(ctx, sessionId)
+    const loopTurn = syncLoopTurn(loopAgent, editTurn)
+    // `loopTurn` is the diagnostic the request ring records; the field is DELIBERATELY
+  // not called `code` - the static checks read `code:` as host error codes and
+  // must not start demanding a user-visible message for an internal sync state.
+  const syncNote = loopTurn
+  if (syncNote === 'unavailable') {
+    noteRequest({ kind: 'reply', sessionId, ok: true, loopTurn: syncNote, turn: editTurn })
+  }
     return {
       kind: 'reply',
       replacementSeq: replacement.seq,
       appendedSeq: appended.seq,
       applied: true,
+      loopTurn,
       shadowed: plan.shadowed,
       ...corrected,
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.2.12",
+  "version": "0.2.15",
   "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",