dsh-as-aistudio 0.4.6 → 0.4.8

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 ## 中文
 
+**0.4.8** —— 跟进内嵌组件：delete 0.2.0、rerun 0.2.7。
+
+- **dsh-delete-turn 0.2.0**：多选删除；载体写上 `op`/`turn`，整轮删除额外写 `deletedTurn`/`deleteIndex`。
+- **dsh-rerun-turn 0.2.7**：遮蔽窗口按表面节点、重放按槽位顺序、生成期间冻结旧轮渲染（不再闪回/空白/丢提问）。
+- 内置版本记录同步更新；`vendor --check` 干净，115/115 全绿。
+
+**0.4.7** —— 打开着的会话不再重新解码整份日志（跟进 `dsh-edit-turn` 0.5.13）。
+
+- **组件跟进**：`dsh-edit-turn` **0.5.13**、`dsh-rerun-turn` 0.2.6、`dsh-delete-turn` 0.1.15、`dsh-markdown-bubble` 0.1.5。
+
+- 单独计时后：插件的全部计算只有几十毫秒，**读日志 + 解压 1,408 ms** 才是瓶颈。现在宿主已经打开的会话直接用内存快照，不再从磁盘重解一遍 —— 编辑笔的出现从"秒级"降到"几十毫秒级"。
+
 **0.4.6** —— 复制已修好，临时诊断撤掉；`/state` 再快一档。
 
 - **组件跟进**：`dsh-edit-turn` **0.5.12**、`dsh-rerun-turn` 0.2.6、`dsh-delete-turn` 0.1.15、`dsh-markdown-bubble` 0.1.5。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-as-aistudio",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "Google-AI-Studio-style turn controls for DeepSeek Harness, in one install: edit a prompt and re-run it, re-run a reply in place, delete a turn from the model context, and render sent prompts as Markdown. Self-contained: the plugin list shows this one row, and the four components are vendored inside it - installing the studio installs nothing else.",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -43,7 +43,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.12'
+    const PLUGIN_VERSION = '0.5.13'
 
     // --- copy -----------------------------------------------------------------
 
@@ -5527,7 +5527,7 @@ window.__ModuleLoader__.load({
     const ROUTE_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.6'
+    const PLUGIN_VERSION = '0.2.7'
 
     // --- copy -----------------------------------------------------------------
 
@@ -5846,6 +5846,9 @@ window.__ModuleLoader__.load({
         // button still carries the previous instance's click handler) must not
         // open a confirm panel on a controller nobody renders any more.
         this.disposed = false
+        // Rows cloned from the rerun turn so the old prompt stays on screen while
+        // the host has already shadowed it (see freezeTurn).
+        this.frozen = []
         this.view = Object.freeze({
           hidden: new Map(),
           reruns: [],
@@ -5938,6 +5941,14 @@ window.__ModuleLoader__.load({
               if (typeof reply.messageId === 'string' && reply.messageId !== '') repliesByMessage.set(reply.messageId, reply)
             }
             const rerunning = data.rerunning === true
+            // Merge the optimistic hide from the click that started this rerun:
+            // /state only reports a rerun's rows once it is COMPLETE, and the
+            // retired prompt must stay hidden while the replay streams in.
+            if (this.pendingHidden instanceof Map) {
+              for (const [seq] of this.pendingHidden) if (!hidden.has(seq)) hidden.set(seq, null)
+              if (!rerunning) this.pendingHidden = null
+            }
+            if (!rerunning) this.releaseFrozen()
             const markerTurns = new Set(Array.isArray(data.markerTurns) ? data.markerTurns.filter((turn) => typeof turn === 'number') : [])
             // Turns whose content a landed rerun fully retired: their
             // process/tail strips hold nothing and must vanish with it.
@@ -6061,9 +6072,45 @@ window.__ModuleLoader__.load({
         this.publish({ notice: null, noticeError: false, dismissedKey: key })
       }
 
+      /**
+       * 冻结目标轮的渲染：宿主在 apply 的那一刻就把这一轮的表面节点遮蔽了，重放的提问
+       * 要等下一次渲染才出现，中间那一帧会没有提问气泡。这里在点击时把这一轮的行
+       * 克隆一份，apply 成功后插回去，重跑结束再撤掉——只影响视觉，不碰日志。
+       */
+      freezeTurn(turn) {
+        this.releaseFrozen()
+        if (!Number.isFinite(turn)) return
+        for (const row of document.querySelectorAll('[data-chat-flow-key][data-chat-turn]')) {
+          if (Number(row.getAttribute('data-chat-turn')) !== turn) continue
+          const parent = row.parentElement
+          if (parent === null) continue
+          const clone = row.cloneNode(true)
+          clone.setAttribute('data-dsrr-frozen', '1')
+          // 别让平台/本插件把它当真实行：去掉流键，摘掉自己注入的动作条。
+          clone.removeAttribute('data-chat-flow-key')
+          for (const junk of clone.querySelectorAll('[data-dsrrh], [class*="_actions"]')) junk.remove()
+          this.frozen.push({ clone, parent, before: row.nextSibling })
+        }
+      }
+
+      applyFrozen() {
+        for (const item of this.frozen) {
+          if (item.clone.parentElement !== null || !item.parent.isConnected) continue
+          const anchor = item.before !== null && item.before.parentElement === item.parent ? item.before : null
+          item.parent.insertBefore(item.clone, anchor)
+        }
+      }
+
+      releaseFrozen() {
+        for (const item of this.frozen) if (item.clone.parentElement !== null) item.clone.remove()
+        this.frozen = []
+      }
+
       async send(entry) {
         if (this.view.pending) return
         this.publish({ pending: true, failure: null, notice: null, noticeError: false })
+        const turn = Number.isFinite(entry.turn) ? entry.turn : entry.reply && Number.isFinite(entry.reply.turn) ? entry.reply.turn : null
+        this.freezeTurn(turn)
         try {
           const res = await fetch(`${ROUTE_PREFIX}/apply`, {
             method: 'POST',
@@ -6071,6 +6118,7 @@ window.__ModuleLoader__.load({
             body: JSON.stringify({ sessionId: this.sessionId, seq: entry.seq, messageId: entry.messageId }),
           })
           const data = await res.json().catch(() => ({}))
+          this.releaseFrozen()
           if (!res.ok || !data.ok) {
             const code = data && data.code ? String(data.code) : 'generic'
             if (code === 'already-retired') {
@@ -6085,14 +6133,22 @@ window.__ModuleLoader__.load({
             this.publish({ pending: false, failure: code, failureDetail: typeof data.error === 'string' && data.error !== '' ? data.error : null })
             return
           }
-          // Do NOT hide the retired rows here: the rerun's replacement (fresh
-          // answer + replay) is not on screen yet, and /state only reports the
-          // retired set for COMPLETED reruns. The rows switch over when the
-          // replay lands.
+          // 宿主已经把这几行遮蔽了（shadow 是同步写下的），所以立刻隐藏它们：
+          // 否则窗口盖掉 edit 载体的一瞬，它压住的原文会重新渲染出来（闪回）。
+          // /state 在重跑完成前不会报告这些行（只报已完成），所以这份乐观集合要
+          // 一直保留到 rerunning 结束，见 load() 里的合并。
+          // 只藏“窗口之外的原文”（被 edit 载体替换掉的那些）。窗口自身的行由
+          // 重跑中的分组逻辑处理，整段藏起来会把界面清空。
+          const immediate = Array.isArray(data.retired) ? data.retired : []
+          const pendingHidden = new Map()
+          for (const seq of immediate) if (typeof seq === 'number') pendingHidden.set(seq, null)
+          this.pendingHidden = pendingHidden
+          this.applyFrozen()
           this.publish({ pending: false, failure: null, rerunning: true })
           this.ensurePolling()
           this.load(true)
         } catch {
+          this.releaseFrozen()
           this.publish({ pending: false, failure: 'generic' })
         }
       }
@@ -7084,6 +7140,14 @@ window.__ModuleLoader__.load({
       'dialog.confirm': '删除',
       'dialog.pending': '删除中…',
       'dialog.retry': '重试',
+      'dialog.title.batch': '删除选中的内容？',
+      'dialog.desc.batch': '选中的消息、步骤与回复将从模型上下文中一并移除；没有被选中的内容保持原样。',
+      'action.tooltip.select': '多选删除',
+      'action.tooltip.selected': '已选中，再点一次取消',
+      'select.count': '已选',
+      'select.unit': '项',
+      'select.delete': '删除选中',
+      'select.cancel': '退出多选',
       'config.ask': '删除时询问',
       'config.hint.ask': '每次删除前都会弹出确认框。',
       'config.hint.auto': '删除会直接执行，不再询问。',
@@ -7124,6 +7188,14 @@ window.__ModuleLoader__.load({
       'dialog.confirm': 'Delete',
       'dialog.pending': 'Deleting...',
       'dialog.retry': 'Retry',
+      'dialog.title.batch': 'Delete the selected items?',
+      'dialog.desc.batch': 'The selected messages, steps and replies leave the model context together; everything not selected stays exactly as it is.',
+      'action.tooltip.select': 'Select for multi-delete',
+      'action.tooltip.selected': 'Selected - click again to unselect',
+      'select.count': 'Selected',
+      'select.unit': '',
+      'select.delete': 'Delete selected',
+      'select.cancel': 'Exit multi-select',
       'config.ask': 'Ask before deleting',
       'config.hint.ask': 'Show a confirmation dialog before every deletion.',
       'config.hint.auto': 'Delete right away without asking.',
@@ -7155,6 +7227,10 @@ window.__ModuleLoader__.load({
       '.dshdt-row{position:relative}',
       '.dshdt-floating{position:absolute;top:2px;right:6px;z-index:2;opacity:0;transition:opacity .12s}',
       '.dshdt-row:hover .dshdt-floating,.dshdt-floating:focus-within{opacity:1}',
+      // While rows are being picked, every toggle has to be reachable without a hover pass over each row.
+      // In the mode the hover host would only sit as an empty box over the
+      // badge, so it steps out entirely instead of fading in.
+      '.dshdt-select-on .dshdt-floating{display:none}',
       '[data-variant="think"]{position:relative}',
       '.dshdt-think-action{position:absolute;top:0;right:4px;opacity:0;transition:opacity .12s}',
       '[data-variant="think"]:hover .dshdt-think-action,.dshdt-think-action:focus-within{opacity:1}',
@@ -7171,6 +7247,31 @@ window.__ModuleLoader__.load({
       '.dshdt-turn:disabled{cursor:default;opacity:.4}',
       '.dshdt-turn svg{width:15px;height:15px}',
       '[data-dshdt-no-target="1"] .dshdt-action{display:none!important}',
+      // In multi-select the toggle is a badge pinned to the row itself: the
+      // action strip of a message row only exists while the pointer is on it,
+      // so a toggle parked inside that strip is invisible exactly when the
+      // mode needs it.
+      '.dshdt-check{width:22px;height:22px;padding:0;display:none;align-items:center;justify-content:center;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.35));border-radius:999px;background:var(--dsw-alias-bg-elevated,#fff);color:var(--dsw-alias-label-tertiary,#8a8f98);cursor:pointer;box-shadow:0 1px 4px rgba(0,0,0,.14);transition:background-color .12s,color .12s}',
+      '.dshdt-select-on{position:relative;opacity:1!important}',
+      '.dshdt-select-on>.dshdt-check{display:inline-flex;position:absolute;top:6px;right:6px;z-index:5}',
+      '.dshdt-check:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.12));color:var(--dsw-alias-button-primary-fill,#4d6bfe)}',
+      '.dshdt-check:focus-visible{outline:2px solid var(--dsw-alias-button-primary-fill,#4d6bfe);outline-offset:2px}',
+      '.dshdt-check svg{width:13px;height:13px}',
+      '.dshdt-checked .dshdt-check{color:var(--dsw-alias-button-primary-fill,#4d6bfe)}',
+      '.dshdt-checked{outline:2px solid var(--dsw-alias-button-primary-fill,#4d6bfe);outline-offset:-2px;border-radius:14px}',
+      '.dshdt-action-host[data-dshdt-badge-only="1"] .dshdt-action,.dshdt-action-host[data-dshdt-badge-only="1"] .dshdt-turn{display:none!important}',
+      '.dshdt-action-host[data-dshdt-badge-only="1"]{pointer-events:none}',
+      '.dshdt-action-host[data-dshdt-badge-only="1"]>.dshdt-check{pointer-events:auto}',
+      '.dshdt-select-on .dshdt-action,.dshdt-select-on .dshdt-turn{display:none!important}',
+      // The header entry sits among the Session utilities: the same 32px pill
+      // the official utilities use, icon-only to stay compact.
+      '.dshdt-header-select{display:inline-flex;align-items:center;justify-content:center;gap:4px;min-width:32px;height:32px;padding:0 8px;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.24));border-radius:18px;background:transparent;color:var(--dsw-alias-label-primary,inherit);font-family:var(--dsw-font-family,inherit);font-size:13px;line-height:20px;cursor:pointer;transition:background-color .12s,color .12s,border-color .12s}',
+      '.dshdt-header-select:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.12))}',
+      '.dshdt-header-select:disabled{color:var(--dsw-alias-label-dimmed,#9aa0aa);cursor:wait}',
+      '.dshdt-header-select svg{flex:none}',
+      '.dshdt-header-select-on{color:var(--dsw-alias-button-primary-fill,#4d6bfe);border-color:var(--dsw-alias-button-primary-fill,#4d6bfe);background:var(--dsw-alias-button-primary-ghost-fill,rgba(77,107,254,.08))}',
+      '.dshdt-selectbar{position:fixed;left:50%;bottom:104px;transform:translateX(-50%);z-index:60;display:flex;align-items:center;gap:10px;padding:8px 12px;border-radius:999px;background:var(--dsw-alias-bg-elevated,#fff);color:var(--dsw-alias-label-primary,inherit);border:1px solid var(--dsw-alias-border-secondary,rgba(127,127,127,.2));box-shadow:0 8px 28px rgba(0,0,0,.18);font-size:13px}',
+      '.dshdt-selectbar-count{min-width:56px;text-align:center;color:var(--dsw-alias-label-secondary,#5c6270)}',
       '.dshdt-dialog-text{margin:0;color:var(--dsw-alias-label-primary,inherit);font-size:14px;line-height:22px}',
       '.dshdt-dialog-note{margin:10px 0 0;color:var(--dsw-alias-label-tertiary,#8a8f98);font-size:13px;line-height:20px}',
       '.dshdt-dialog-warn{margin:10px 0 0;color:var(--dsw-alias-state-warn-primary,#a15c00);font-size:13px;line-height:20px}',
@@ -7225,6 +7326,16 @@ window.__ModuleLoader__.load({
       ).join('') +
       '</svg>'
 
+    // Multi-select glyph: a checkbox square with a tick.
+    const CHECK_ICON_PATHS = ['M2.7 2.7h10.6v10.6H2.7z', 'M5.3 8.15l1.95 2 3.5-4.05']
+    const CHECK_ICON_MARKUP =
+      '<svg width="16" height="16" viewBox="0 0 16 16" fill="none" aria-hidden="true">' +
+      CHECK_ICON_PATHS.map(
+        (d) =>
+          '<path d="' + d + '" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>',
+      ).join('') +
+      '</svg>'
+
     function TrashIcon() {
       return jsx('svg', {
         width: 16,
@@ -7238,6 +7349,21 @@ window.__ModuleLoader__.load({
       })
     }
 
+    // The multi-select mark: a checkbox square with a tick, so the header entry
+    // reads as "select rows" rather than "delete".
+    function CheckIcon() {
+      return jsx('svg', {
+        width: 16,
+        height: 16,
+        viewBox: '0 0 16 16',
+        fill: 'none',
+        'aria-hidden': true,
+        children: CHECK_ICON_PATHS.map((d, index) =>
+          jsx('path', { d, stroke: 'currentColor', strokeWidth: 1.2, strokeLinecap: 'round', strokeLinejoin: 'round' }, index),
+        ),
+      })
+    }
+
     // --- controller -----------------------------------------------------------
 
     class DeletionController {
@@ -7265,6 +7391,11 @@ window.__ModuleLoader__.load({
           loaded: false,
           loadError: false,
           dialog: null,
+          // Multi-select: while `selecting` is on every deletable row offers a
+          // checkbox, and one request lands every checked window at once.
+          selecting: false,
+          // selectionKey -> target, so a row keeps its mark across refreshes.
+          selected: new Map(),
           pending: false,
           failure: null,
           // How many unrelated nodes the last attempt reported it would also
@@ -7351,6 +7482,95 @@ window.__ModuleLoader__.load({
         return pending
       }
 
+      // Entering/leaving multi-select. Leaving drops the selection, so a later
+      // entry never starts with rows the user no longer sees as marked.
+      setSelecting(on) {
+        if (this.view.pending) return
+        const selecting = on === true
+        if (selecting === this.view.selecting) return
+        this.publish({ selecting, selected: selecting ? this.view.selected : new Map(), dialog: null, failure: null, foreignCount: 0 })
+      }
+
+      toggleSelected(key, target) {
+        if (this.view.pending || typeof key !== 'string' || key === '' || target === null || target === undefined) return
+        const selected = new Map(this.view.selected)
+        if (selected.has(key)) selected.delete(key)
+        else selected.set(key, target)
+        this.publish({ selected })
+      }
+
+      // The batch entry: with "ask" on it opens the confirmation dialog, with it
+      // off it deletes straight away and only surfaces a dialog when the attempt
+      // failed (a silent failure would have nowhere to go).
+      requestBatch() {
+        const count = this.view.selected.size
+        if (count === 0 || this.view.pending) return
+        if (getPrefs().ask) {
+          this.publish({ dialog: { mode: 'batch', count }, failure: null, foreignCount: 0 })
+          return
+        }
+        void this.performBatch().then((result) => {
+          if (result.failure !== null) this.publish({ dialog: { mode: 'batch', count }, pending: false, failure: result.failure })
+        })
+      }
+
+      // One request carries every selected target. The host fuses the windows
+      // and lands them back to back, so a batch can never land half of itself.
+      async performBatch(options) {
+        if (this.view.pending) return { failure: null }
+        const force = options !== undefined && options.force === true
+        const requested = [...this.view.selected.values()]
+        if (requested.length === 0) return { failure: null }
+        this.publish({ pending: true, failure: null, foreignCount: 0 })
+        try {
+          await this.load(true)
+          // A target the fresh surface no longer holds means the log moved under
+          // the selection: refuse the whole batch instead of landing the part
+          // that still resolves.
+          const resolved = requested.map((target) => this.resolveTarget(target))
+          if (resolved.some((target) => target === null || target === undefined)) {
+            this.publish({ pending: false, failure: 'stale' })
+            return { failure: 'stale' }
+          }
+          const targets = resolved.map((target) => {
+            const out = { mode: target.mode }
+            if (typeof target.seq === 'number') out.seq = target.seq
+            if (typeof target.turn === 'number') out.turn = target.turn
+            if (typeof target.messageId === 'string') out.messageId = target.messageId
+            return out
+          })
+          const res = await fetch(`${ROUTE_PREFIX}/delete`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ sessionId: this.sessionId, targets, ...(force ? { force: true } : {}) }),
+          })
+          const data = await res.json().catch(() => ({}))
+          if (!res.ok || !data.ok) {
+            const code = data && data.code ? String(data.code) : 'generic'
+            const foreignCount = data && data.details && typeof data.details.foreign === 'number' ? data.details.foreign : 0
+            this.publish({ pending: false, failure: code, foreignCount })
+            // `partial` means the log moved between two appends: re-read so the
+            // transcript shows what actually landed, not the pre-batch picture.
+            if (code === 'partial') await this.load(true)
+            return { failure: code }
+          }
+          const hidden = new Map(this.view.hidden)
+          for (const item of Array.isArray(data.hidden) ? data.hidden : []) {
+            if (item && typeof item.seq === 'number') hidden.set(item.seq, typeof item.mode === 'string' ? item.mode : 'message')
+          }
+          const hiddenVia = new Map(this.view.hiddenVia)
+          for (const [via, seq] of hiddenViaOf(data.hidden)) hiddenVia.set(via, seq)
+          this.animateOnce = true
+          // Leaving the mode after a landed batch keeps the next click an
+          // ordinary delete: the marks are gone, so staying would only widen it.
+          this.publish({ pending: false, selecting: false, dialog: null, hidden, hiddenVia, selected: new Map(), loaded: true, loadError: false })
+          return { failure: null }
+        } catch {
+          this.publish({ pending: false, failure: 'generic' })
+          return { failure: 'generic' }
+        }
+      }
+
       open(target) {
         this.load()
         this.publish({ dialog: target, failure: null })
@@ -7365,7 +7585,13 @@ window.__ModuleLoader__.load({
       // nodes" report, which is the only refusal the dialog turns into a second
       // question instead of a dead end.
       async confirm(options) {
-        await this.perform(this.view.dialog, { force: options && options.force === true })
+        const force = options !== undefined && options.force === true
+        const target = this.view.dialog
+        if (target !== null && typeof target === 'object' && target.mode === 'batch') {
+          await this.performBatch({ force })
+          return
+        }
+        await this.perform(target, { force })
       }
 
       // The entry every action uses. With "ask" on, it opens the confirmation
@@ -7503,6 +7729,18 @@ window.__ModuleLoader__.load({
       return typeof seq === 'number' ? { mode: 'turn', seq, label: 'turn' } : null
     }
 
+    // Stable identity of one selectable target across snapshot refreshes: a
+    // message/step addresses a durable seq, a reply/turn a turn number. The key
+    // is what the controller keys its selection map by, so a re-read that moves
+    // a row's live seq cannot silently keep a stale mark.
+    function selectionKey(target) {
+      if (!target || typeof target !== 'object') return ''
+      if (typeof target.seq === 'number') return target.mode + ':' + String(target.seq)
+      if (typeof target.turn === 'number') return target.mode + ':t' + String(target.turn)
+      if (typeof target.messageId === 'string') return target.mode + ':m' + target.messageId
+      return ''
+    }
+
     function seqsFor(node) {
       const data = node.data || {}
       const out = []
@@ -7660,7 +7898,7 @@ window.__ModuleLoader__.load({
       host.className = kind === 'think' ? HOST_CLASS + ' ' + THINK_CLASS : HOST_CLASS
       host.setAttribute(HOST_MARK, '1')
       if (kind === 'think') host.setAttribute(THINK_MARK, '1')
-      let button = host.querySelector('button')
+      let button = host.querySelector('button.dshdt-action')
       if (button === null) {
         button = document.createElement('button')
         button.type = 'button'
@@ -7684,7 +7922,20 @@ window.__ModuleLoader__.load({
           host.appendChild(turn)
         }
       }
-      return { host, button, turn }
+      // The multi-select checkbox rides in the same host (same namespace, same
+      // adoption rule); it is only ever VISIBLE while the mode is on.
+      let check = null
+      if (kind !== 'think') {
+        check = host.querySelector('.dshdt-check')
+        if (check === null) {
+          check = document.createElement('button')
+          check.type = 'button'
+          check.className = 'dshdt-check dshdt-row-action'
+          check.innerHTML = CHECK_ICON_MARKUP
+          host.appendChild(check)
+        }
+      }
+      return { host, button, turn, check }
     }
 
     // Drop every node this plugin injected. Matched through this plugin's own
@@ -7697,6 +7948,8 @@ window.__ModuleLoader__.load({
     function sweepInjectedNodes() {
       for (const host of document.querySelectorAll('[' + HOST_MARK + '="1"]')) host.remove()
       for (const host of document.querySelectorAll('.' + HOST_CLASS)) host.remove()
+      // A toggle parked on a row is not inside any host, so it is swept by name.
+      for (const node of document.querySelectorAll('.dshdt-check')) node.remove()
       // These entries now point at detached nodes; the next injection re-adopts
       // from the DOM instead of trusting them.
       rowActions = new WeakMap()
@@ -7770,11 +8023,23 @@ window.__ModuleLoader__.load({
       const entry = rowActions.get(row)
       if (!entry) return
       entry.host.remove()
+      // The toggle may be on the row rather than in the host while the mode is
+      // on, so the row is swept of direct children that belong to the host.
+      for (const node of row.querySelectorAll('.dshdt-check')) {
+        if (node.parentElement === row) node.remove()
+      }
       rowActions.delete(row)
+      delete row.dataset.dshdtSelect
+      row.classList.remove('dshdt-select-on', 'dshdt-checked')
     }
 
-    function injectRowAction(row, node, target, turnTarget, controller, t) {
-      const label = t(`action.tooltip.${target.label}`)
+    function injectRowAction(row, node, target, turnTarget, view, controller, t, pickTarget) {
+      // A row can carry the multi-select badge without carrying a hover action:
+      // a turn's answer text has no row-level scope of its own, only a reply
+      // scope, and that scope already lives in the reply action strip.
+      const badgeOnly = target === null
+      const pick = pickTarget === undefined || pickTarget === null ? target : pickTarget
+      const label = badgeOnly ? '' : t(`action.tooltip.${target.label}`)
       let entry = rowActions.get(row)
       if (!entry) {
         // Never a second host on a row that already carries one: an earlier
@@ -7782,20 +8047,24 @@ window.__ModuleLoader__.load({
         entry = adoptHost(findOwnedHost(row, false), 'row')
         rowActions.set(row, entry)
       }
-      const { host, button, turn } = entry
+      const { host, button, turn, check } = entry
+      if (badgeOnly) host.dataset.dshdtBadgeOnly = '1'
+      else delete host.dataset.dshdtBadgeOnly
       if (button.getAttribute('aria-label') !== label) {
         button.setAttribute('aria-label', label)
         button.setAttribute('title', label)
       }
-      button.onclick = (event) => {
-        event.preventDefault()
-        event.stopPropagation()
-        controller.trigger(target)
-      }
+      button.onclick = badgeOnly
+        ? null
+        : (event) => {
+            event.preventDefault()
+            event.stopPropagation()
+            controller.trigger(target)
+          }
       // The second action is wired only where a turn target exists (and stays
       // hidden by the row attribute otherwise), so a row can never offer an
       // operation the host would refuse for the wrong reason.
-      if (turn !== null && turn !== undefined) {
+      if (!badgeOnly && turn !== null && turn !== undefined) {
         const turnLabel = t('action.tooltip.turn')
         if (turn.getAttribute('aria-label') !== turnLabel) {
           turn.setAttribute('aria-label', turnLabel)
@@ -7810,6 +8079,39 @@ window.__ModuleLoader__.load({
                 controller.trigger(turnTarget)
               }
       }
+      // Multi-select: the same host carries the toggle. Outside selection mode
+      // it enters the mode AND marks this row, so one click both opens the bar
+      // and shows what the next click would do.
+      if (check !== null && check !== undefined) {
+        const key = selectionKey(pick)
+        const selecting = view.selecting === true
+        const selected = selecting && key !== '' && view.selected.has(key)
+        if (selecting) {
+          row.dataset.dshdtSelect = '1'
+          row.classList.add('dshdt-select-on')
+          // Physically move the node onto the row for the duration of the
+          // mode; the same element and handler go back to the host after.
+          if (check.parentElement !== row) row.appendChild(check)
+        } else {
+          delete row.dataset.dshdtSelect
+          row.classList.remove('dshdt-select-on')
+          if (check.parentElement !== host) host.appendChild(check)
+        }
+        if (selected) row.classList.add('dshdt-checked')
+        else row.classList.remove('dshdt-checked')
+        const checkLabel = selected ? t('action.tooltip.selected') : t('action.tooltip.select')
+        if (check.getAttribute('aria-label') !== checkLabel) {
+          check.setAttribute('aria-label', checkLabel)
+          check.setAttribute('title', checkLabel)
+        }
+        check.setAttribute('aria-pressed', selected ? 'true' : 'false')
+        check.onclick = (event) => {
+          event.preventDefault()
+          event.stopPropagation()
+          if (!controller.view.selecting) controller.setSelecting(true)
+          controller.toggleSelected(key, pick)
+        }
+      }
       const anchor = node.kind === 'user' || node.kind === 'steering' ? row.querySelector('[class*="_actions"]') : null
       if (anchor) {
         host.classList.remove('dshdt-floating')
@@ -7947,13 +8249,22 @@ window.__ModuleLoader__.load({
         const hidden = orphaned || isRowHidden(view.hidden, view.hiddenVia, seqs)
         setRowHidden(row, hidden, animate)
         const target = hidden ? null : liveTarget(targetFor(node), view.edits)
-        const covered = target !== null || slotCoversRow(node)
+        // A row with no scope of its own (the answer text of a turn) still earns
+        // the badge when its turn's reply is deletable: ticking it deletes that
+        // answer and keeps the prompt, which is the only scope the row owns.
+        const turnNumber = turn === null || turn === '' ? null : Number(turn)
+        const replyPick =
+          !hidden && turnNumber !== null && Number.isFinite(turnNumber) && view.replyTurns.has(turnNumber)
+            ? { mode: 'reply', turn: turnNumber, label: 'reply' }
+            : null
+        const covered = target !== null || slotCoversRow(node) || replyPick !== null
         const deletable = !hidden && covered && rowDeletable(node, seqs, view)
         // The turn-delete entry rides on the same gates as the delete entry: a
         // row whose content already left the context offers neither.
         const turnTarget =
           deletable && turnTargetFor(node) !== null && view.turnSeqs.has(target.seq) ? liveTarget(turnTargetFor(node), view.edits) : null
-        if (deletable && target !== null) injectRowAction(row, node, target, turnTarget, controller, t)
+        const pickTarget = target !== null ? target : deletable ? replyPick : null
+        if (deletable && pickTarget !== null) injectRowAction(row, node, target, turnTarget, view, controller, t, pickTarget)
         else removeRowAction(row)
         if (deletable && target !== null && turnTarget !== null) row.dataset.dshdtTurn = '1'
         else delete row.dataset.dshdtTurn
@@ -8056,6 +8367,63 @@ window.__ModuleLoader__.load({
       })
     }
 
+    // The multi-select bar. Fixed placement keeps it out of the slot's layout:
+    // `conversation.input.overlay` is drawn over the composer, so an in-flow bar
+    // would push the input area around (and re-measure it) on every toggle.
+    // Multi-select is a MODE: entering it has to be possible without hovering a
+    // row first, so the entry lives in the Session header - always visible,
+    // next to the other Session utilities. The per-row toggles only appear once
+    // the mode is on (their rows carry `data-dshdt-select` then).
+    function SelectToggle({ useDeletion, controller, t }) {
+      const view = useDeletion((state) => state)
+      const selecting = view.selecting === true
+      const label = selecting ? t('select.cancel') : t('action.tooltip.select')
+      return jsx('button', {
+        type: 'button',
+        className: selecting ? 'dshdt-header-select dshdt-header-select-on' : 'dshdt-header-select',
+        'aria-label': label,
+        'aria-pressed': selecting ? 'true' : 'false',
+        title: label,
+        disabled: view.pending,
+        onClick: (event) => {
+          event.preventDefault()
+          event.stopPropagation()
+          controller.setSelecting(!selecting)
+        },
+        children: jsx(CheckIcon, {}),
+      })
+    }
+
+    function SelectionBar({ view, controller, t }) {
+      if (view.selecting !== true) return null
+      const count = view.selected.size
+      return jsxs('div', {
+        className: 'dshdt-selectbar',
+        role: 'toolbar',
+        children: [
+          jsx('span', {
+            className: 'dshdt-selectbar-count',
+            children: `${t('select.count')} ${count}${t('select.unit')}`,
+          }),
+          jsx(primitives.Button, {
+            variant: 'ghost',
+            size: 'md',
+            disabled: view.pending,
+            onClick: () => controller.setSelecting(false),
+            children: t('select.cancel'),
+          }),
+          jsx(primitives.Button, {
+            variant: 'primary',
+            size: 'md',
+            className: 'dshdt-danger',
+            disabled: view.pending || count === 0,
+            onClick: () => controller.requestBatch(),
+            children: view.pending ? t('dialog.pending') : t('select.delete'),
+          }),
+        ],
+      })
+    }
+
     function ConfirmDialog({ view, controller, t }) {
       const target = view.dialog
       const mode = target && typeof target.mode === 'string' ? target.mode : 'message'
@@ -8165,7 +8533,11 @@ window.__ModuleLoader__.load({
       return jsxs(Fragment, {
         // The slot root carries this plugin's namespace as well (I3). It is
         // React's node: the dispose sweep must not touch it.
-        children: [jsx('span', { hidden: true, 'data-dshdt-overlay': '1' }), jsx(ConfirmDialog, { view, controller, t })],
+        children: [
+          jsx('span', { hidden: true, 'data-dshdt-overlay': '1' }),
+          jsx(SelectionBar, { view, controller, t }),
+          jsx(ConfirmDialog, { view, controller, t }),
+        ],
       })
     }
 
@@ -8216,6 +8588,20 @@ window.__ModuleLoader__.load({
         ),
       )
 
+      // The always-visible door into multi-select, beside the Session utilities.
+      ctx.slots.inject('conversation.session.header.utilities', () =>
+        ctx.slots.register(
+          {
+            name: 'conversation.session.header.utilities',
+            id: 'delete-turn',
+            order: 10,
+            locale: NS,
+            inject: (sessionId) => ({ hooks: { deletion: controllerFor(sessionId) }, controller: controllerFor(sessionId) }),
+          },
+          SelectToggle,
+        ),
+      )
+
       ctx.slots.inject('conversation.input.overlay', () =>
         ctx.slots.register(
           {
@@ -9197,7 +9583,7 @@ window.__ModuleLoader__.load({
     const NS = 'dsh-as-aistudio'
 
     /** Keep in sync with package.json and src/components.js. */
-    const PLUGIN_VERSION = '0.4.6'
+    const PLUGIN_VERSION = '0.4.8'
 
     /** Presence marker the live verifier reads. */
     const DEBUG_KEY = '__DSH_AS_AISTUDIO__'

package/src/components.js

@@ -26,7 +26,7 @@
 export const STUDIO_ID = 'dsh-as-aistudio'
 
 /** Keep in sync with package.json and src/client.js. */
-export const STUDIO_VERSION = '0.4.6'
+export const STUDIO_VERSION = '0.4.8'
 
 /**
  * The AI Studio action strip this studio composes, in the order the user meets

package/src/vendor/host/dsh-delete-turn.js

@@ -1,6 +1,6 @@
 // dsh-delete-turn host half (dsh-delete-turn.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-delete-turn/src/index.js  (v0.1.15, sha256 75377700ba2a6436)
+// Source: ../dsh-delete-turn/src/index.js  (v0.2.0, sha256 5dfc53e5c47750f5)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -11,6 +11,7 @@
 //
 //   GET  /dsh-delete-turn/state?sessionId=<id>
 //   POST /dsh-delete-turn/delete   { sessionId, mode, seq?, messageId?, turn? }
+//                                  { sessionId, targets: [{ mode, seq?, turn? }] }
 //
 // A deletion appends ONE turn-less `user/message` carrier carrying the official
 // surface intent `{ surfaceOp: { op: 'replace', startSeq, endSeq } }` and the
@@ -44,6 +45,7 @@ import {
   hiddenEntriesOfFold,
   isBusy,
   openTurn,
+  planBatch,
   planRange,
   turnableSeqs,
 } from './dsh-delete-turn.logic.js'
@@ -420,8 +422,13 @@ async function stopActiveTurn(ctx, sessionId, events) {
 }
 
 async function deleteTarget(ctx, sessionId, body) {
+  // Two shapes: one target (`mode` + address) or a multi-select batch
+  // (`targets`). Both end in the SAME append path - a batch is just several
+  // disjoint range replaces landed back to back.
+  const batch = Array.isArray(body.targets)
+  if (batch && body.targets.length === 0) throw new HttpError(400, 'invalid', 'targets must not be empty')
   const mode = typeof body.mode === 'string' ? body.mode : ''
-  if (!MODES.has(mode)) throw new HttpError(400, 'invalid', 'mode must be message, step, reply or turn')
+  if (!batch && !MODES.has(mode)) throw new HttpError(400, 'invalid', 'mode must be message, step, reply or turn')
   const session = await resolveSession(ctx, sessionId)
   if (!session || typeof session.append !== 'function') {
     throw new HttpError(409, 'session-not-active', 'the session is not open in DSH')
@@ -438,17 +445,21 @@ async function deleteTarget(ctx, sessionId, body) {
   }
 
   const surfaceNodes = surfaceOf(ctx, sessionId, events)
-  let plan
+  let plans
   try {
-    plan = planRange(events, surfaceNodes, {
-      mode,
-      seq: typeof body.seq === 'number' ? body.seq : undefined,
-      messageId: typeof body.messageId === 'string' ? body.messageId : undefined,
-      turn: typeof body.turn === 'number' ? body.turn : undefined,
-    })
+    plans = batch
+      ? planBatch(events, surfaceNodes, body.targets)
+      : [
+          planRange(events, surfaceNodes, {
+            mode,
+            seq: typeof body.seq === 'number' ? body.seq : undefined,
+            messageId: typeof body.messageId === 'string' ? body.messageId : undefined,
+            turn: typeof body.turn === 'number' ? body.turn : undefined,
+          }),
+        ]
   } catch (error) {
     if (error instanceof PlanError) {
-      const status = error.code === 'not-deletable' ? 400 : 409
+      const status = error.code === 'not-deletable' || error.code === 'invalid' ? 400 : 409
       throw new HttpError(status, error.code, error.message)
     }
     throw error
@@ -458,14 +469,18 @@ async function deleteTarget(ctx, sessionId, body) {
   // foreign injected row, say). Deleting them is not refused - it is a decision
   // the user must make explicitly: without `force` the route reports how many
   // there are, and the client turns that into a second, forced confirmation.
-  if (plan.foreign.length > 0 && body.force !== true) {
-    throw new HttpError(409, 'range-not-clean', `the window would also remove ${plan.foreign.length} unrelated node(s)`, { foreign: plan.foreign.length })
+  const foreignCount = plans.reduce((sum, plan) => sum + plan.foreign.length, 0)
+  if (foreignCount > 0 && body.force !== true) {
+    throw new HttpError(409, 'range-not-clean', `the window would also remove ${foreignCount} unrelated node(s)`, { foreign: foreignCount })
   }
 
   // The live surface is the append authority; a node that vanished between the
-  // read and this check means another writer landed first.
-  for (const seq of plan.shadowed) {
-    if (!surfaceNodes.includes(seq)) throw new HttpError(409, 'stale', 'the session changed, retry')
+  // read and this check means another writer landed first. Every window is
+  // checked before the first append, so a batch can never land half of itself.
+  for (const plan of plans) {
+    for (const seq of plan.shadowed) {
+      if (!surfaceNodes.includes(seq)) throw new HttpError(409, 'stale', 'the session changed, retry')
+    }
   }
 
   // The carrier must be a turn-less `user/message`.
@@ -484,31 +499,69 @@ async function deleteTarget(ctx, sessionId, body) {
   // safest accepted content is a single ZERO-WIDTH SPACE (a readable marker
   // like "[deleted]" is quoted back by the model, and empty content is refused
   // by gateways whose adapter predates that skip).
-  let replacement
-  try {
-    replacement = session.append(
-      'user/message',
-      {
-        id: randomUUID(),
-        role: 'user',
-        content: silentCarrierFor(ctx, events) ? [] : [{ type: 'text', text: '\u200b' }],
-        // v4 format: plugin wrappers are retired; the producer kind carries the id.
-        source: { kind: `plugin:${PLUGIN_ID}` },
-      },
-      {
-        surfaceOp: { op: 'replace', startSeq: plan.startSeq, endSeq: plan.endSeq },
-        sourceEventSeqs: plan.shadowed,
-      },
-    )
-  } catch (error) {
-    throw new HttpError(409, 'stale', `the surface refused the replacement: ${String((error && error.message) || error)}`)
+  const replacements = []
+  const hidden = []
+  const silent = silentCarrierFor(ctx, events)
+  // 标注（给日志读者用的“注释”，不是替换语义）：整轮删除才会让可见轮号与日志轮号
+  // 分叉，所以只有 `mode: 'turn'` 成为墓碑（tombstone）。`deleteIndex` 是这条记录的
+  // 序号，配合 `deletedTurn` 足以复原“可见轮 ↔ 日志轮”的映射：
+  //   可见轮(L) = L − #{ 已删日志轮 < L }
+  let deleteOrdinal = 0
+  for (const event of events) {
+    if (event?.data?.source?.kind === `plugin:${PLUGIN_ID}` && Number.isSafeInteger(event?.data?.source?.deletedTurn)) deleteOrdinal += 1
+  }
+  // Ascending surface order, so each append is validated against a log the
+  // previous one already changed - the windows are disjoint, so a later
+  // window's anchors are untouched by an earlier append.
+  for (const plan of plans) {
+    // 一条载体一条注释；整轮删除才递增墓碑序号（同一批里的多轮删除必须各占一个号）。
+    const carrierSource = { kind: `plugin:${PLUGIN_ID}`, op: 'delete', turn: plan.turn }
+    if (plan.mode === 'turn') {
+      deleteOrdinal += 1
+      carrierSource.deletedTurn = plan.turn
+      carrierSource.deleteIndex = deleteOrdinal
+    }
+    let replacement
+    try {
+      replacement = session.append(
+        'user/message',
+        {
+          id: randomUUID(),
+          role: 'user',
+          content: silent ? [] : [{ type: 'text', text: '\u200b' }],
+          // v4 format: plugin wrappers are retired; the producer kind carries the id.
+          // `op` / `turn` 让任何读者一眼看出“谁、第几轮、删了什么”；整轮删除额外写
+          // `deletedTurn` + `deleteIndex`，它是可见轮号与日志轮号之间的唯一桥梁。
+          source: carrierSource,
+        },
+        {
+          surfaceOp: { op: 'replace', startSeq: plan.startSeq, endSeq: plan.endSeq },
+          sourceEventSeqs: plan.shadowed,
+        },
+      )
+    } catch (error) {
+      // A window refused after an earlier one already landed: report it as a
+      // partial batch instead of pretending nothing happened, so the client can
+      // re-read the log and show the truth.
+      if (replacements.length > 0) {
+        await flushSession(ctx, session).catch(() => undefined)
+        throw new HttpError(409, 'partial', `only ${replacements.length} of ${plans.length} window(s) landed: ${String((error && error.message) || error)}`, {
+          landed: replacements.length,
+          total: plans.length,
+        })
+      }
+      throw new HttpError(409, 'stale', `the surface refused the replacement: ${String((error && error.message) || error)}`)
+    }
+    replacements.push(replacement.seq)
+    for (const seq of plan.shadowed) hidden.push({ seq, mode: plan.mode })
   }
   const flush = await flushSession(ctx, session)
 
   return {
-    replacementSeq: replacement.seq,
+    replacementSeq: replacements[replacements.length - 1],
+    ...(replacements.length > 1 ? { replacements } : {}),
     ...flush,
-    hidden: plan.shadowed.map((seq) => ({ seq, mode: plan.mode })),
+    hidden,
   }
 }
 

package/src/vendor/host/dsh-delete-turn.logic.js

@@ -1,6 +1,6 @@
 // dsh-delete-turn host half (dsh-delete-turn.logic.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-delete-turn/src/logic.js  (v0.1.15, sha256 900c08468355aff3)
+// Source: ../dsh-delete-turn/src/logic.js  (v0.2.0, sha256 6da16435446356ca)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -543,6 +543,77 @@ export function planRange(events, surfaceNodes, request) {
 
   throw new PlanError('not-deletable', `unsupported mode ${String(mode)}`)
 }
+
+/**
+ * Plan several UI targets into the fewest disjoint surface windows.
+ *
+ * A multi-select delete is not N independent deletes. Two selected rows can
+ * share one window (a step inside a reply, a message inside its turn), and
+ * deleting the first would make the second's anchors stale before it is even
+ * attempted. Every target is therefore planned against the SAME pre-delete
+ * surface, the windows are sorted by surface position, and neighbours —
+ * overlapping or directly adjacent — are fused into one replacement. Fusing
+ * only neighbours keeps the union exact: no node is swallowed that was not
+ * already inside one of the parts, so the foreign report stays the one the
+ * single-target path would have produced.
+ *
+ * @param events - complete contiguous raw event log.
+ * @param surfaceNodes - current surface seqs in model order.
+ * @param targets - array of `{ mode, seq?, messageId?, turn? }`.
+ * @returns one plan per fused window, in surface order. `mode` is the single
+ *   part's mode when nothing was fused and `batch` otherwise; `parts` names the
+ *   targets the window covers.
+ * @throws {PlanError} when any target cannot be planned.
+ */
+export function planBatch(events, surfaceNodes, targets) {
+  if (!Array.isArray(targets) || targets.length === 0) {
+    throw new PlanError('invalid', 'targets must be a non-empty array')
+  }
+  const nodeIndex = new Map(surfaceNodes.map((seq, index) => [seq, index]))
+  const bySeq = new Map(events.map((event) => [event.seq, event]))
+  const plans = []
+  const seen = new Set()
+  for (const request of targets) {
+    if (!request || typeof request !== 'object') throw new PlanError('invalid', 'every target must be an object')
+    const key = [request.mode, request.seq, request.turn, request.messageId].join('|')
+    if (seen.has(key)) continue
+    seen.add(key)
+    const plan = planRange(events, surfaceNodes, request)
+    plans.push({ plan, startIdx: nodeIndex.get(plan.startSeq), endIdx: nodeIndex.get(plan.endSeq) })
+  }
+  plans.sort((a, b) => a.startIdx - b.startIdx || a.endIdx - b.endIdx)
+  const groups = []
+  for (const item of plans) {
+    const last = groups[groups.length - 1]
+    if (last !== undefined && item.startIdx <= last.endIdx + 1) {
+      last.endIdx = Math.max(last.endIdx, item.endIdx)
+      last.parts.push(item.plan)
+      continue
+    }
+    groups.push({ startIdx: item.startIdx, endIdx: item.endIdx, parts: [item.plan] })
+  }
+  return groups.map((group) => {
+    const shadowed = surfaceNodes.slice(group.startIdx, group.endIdx + 1)
+    const members = []
+    for (const plan of group.parts) {
+      for (const seq of plan.shadowed) if (!members.includes(seq)) members.push(seq)
+    }
+    const foreign = foreignNodes(shadowed, members, bySeq)
+    const first = group.parts[0]
+    return {
+      mode: group.parts.length === 1 ? first.mode : 'batch',
+      targetSeq: first.targetSeq,
+      startSeq: shadowed[0],
+      endSeq: shadowed[shadowed.length - 1],
+      shadowed,
+      foreign,
+      turn: first.turn,
+      step: first.step,
+      parts: group.parts.map((plan) => ({ mode: plan.mode, targetSeq: plan.targetSeq })),
+    }
+  })
+}
+
 // --- target resolution -------------------------------------------------------
 
 /**

package/src/vendor/host/dsh-edit-turn.js

@@ -1,6 +1,6 @@
 // dsh-edit-turn host half (dsh-edit-turn.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-edit-turn/lib/index.js  (v0.5.12, sha256 6adfd5b9699657d5)
+// Source: ../dsh-edit-turn/lib/index.js  (v0.5.13, sha256 85d229824536a84b)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -85,7 +85,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.12'
+export const PLUGIN_VERSION = '0.5.13'
 
 // 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
@@ -1491,6 +1491,13 @@ function eventsFromLive(session) {
 // Live-preferred read through the public query service; the live session's own
 // snapshot is the fallback when the service is absent.
 async function readEvents(ctx, sessionId) {
+  // A session the host has open answers from memory. Going through the query
+  // service instead makes the route re-decode the whole log from disk first:
+  // measured 1.4 s for a 15 MB log, while every computation this route does on
+  // top of it adds up to a few tens of milliseconds. That read was the entire
+  // reason the edit entry took seconds to appear.
+  const live = eventsFromLive(findLiveSession(ctx, sessionId))
+  if (live !== undefined && live.length > 0) return live
   const query = ctx.get('sessionQuery')
   if (query && typeof query.readSession === 'function') {
     try {

package/src/vendor/host/dsh-edit-turn.patch.js

@@ -1,6 +1,6 @@
 // dsh-edit-turn host half (dsh-edit-turn.patch.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-edit-turn/lib/patch.js  (v0.5.12, sha256 5e1e8cce1d168f6c)
+// Source: ../dsh-edit-turn/lib/patch.js  (v0.5.13, sha256 5e1e8cce1d168f6c)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-rerun-turn.js

@@ -1,6 +1,6 @@
 // dsh-rerun-turn host half (dsh-rerun-turn.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-rerun-turn/lib/index.js  (v0.2.6, sha256 3e20b1a0a07cf213)
+// Source: ../dsh-rerun-turn/lib/index.js  (v0.2.7, sha256 9f163488f55fb398)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -90,7 +90,7 @@ export const PLUGIN_ID = 'dsh-rerun-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.2.6'
+export const PLUGIN_VERSION = '0.2.7'
 
 const ROUTE_PREFIX = '/dsh-rerun-turn'
 // A session id is an OPAQUE string to DSH: the host's own schema is
@@ -952,10 +952,34 @@ export function planRerun(events, surfaceNodes, request) {
   }
   const span = resolved.span
   const promptEvent = bySeq.get(livePromptSeq)
-  const shadowed = surfaceNodes.slice(nodeIndex.get(livePromptSeq))
-  if (shadowed.length === 0 || shadowed[0] !== livePromptSeq) {
+  const slotWindow = surfaceNodes.slice(nodeIndex.get(livePromptSeq))
+  if (slotWindow.length === 0 || slotWindow[0] !== livePromptSeq) {
     throw new RerunPlanError('not-rerunnable', 'the prompt does not open a rerun window')
   }
+  // 单一来源：窗口就是「提示词槽位到表面末尾」这一段**表面**节点，按表面顺序。
+  // 宿主的 replace 按表面位置解析（`indexOf(startSeq)`..`indexOf(endSeq)`），所以
+  // 区间端点取这段的首尾即可；区间覆盖的正是这整段，不会多也不会少。
+  const shadowed = slotWindow
+  // 窗口里若站着一条 edit 载体（它占着提示词的槽位，正文是新文本），把它顶掉的原消息
+  // 也一并退役：否则界面在 rerun 期间会把原文重新渲染出来（“回复数字1”闪回）。
+  // 只加进 `retired`（写进 sourceEventSeqs 让客户端一起隐藏），不加进 `shadowed`
+  // （重放不复制它，否则提示词会出现两份）。
+  const replacements = foldSurface(events).replacements
+  const carrierTargets = new Map()
+  for (const replacement of replacements) carrierTargets.set(replacement.seq, replacement.shadowed)
+  const retired = new Set(shadowed)
+  for (const seq of shadowed) {
+    const targets = carrierTargets.get(seq)
+    if (targets === undefined) continue
+    for (const target of targets) retired.add(target)
+  }
+  // 只有**提示词槽位上那条载体**被遮蔽时会让别人重新露出来：它就是 edit 载体，
+  // 它的替换目标（原文）会在窗口盖掉它的一瞬回到表面。只把这**一跳**的目标交出去
+  // 给客户端做乐观隐藏；多跳链上的目标属于别的轮次，隐藏它们会把界面清空。
+  const restored = carrierTargets.get(shadowed[0]) ?? []
+  const retiredList = [...retired].sort((left, right) => left - right)
+  const windowLo = retiredList[0]
+  const windowHi = retiredList[retiredList.length - 1]
   if (promptEvent.data && Array.isArray(promptEvent.data.content)) {
     const files = promptEvent.data.content.filter((block) => block && block.type === 'file')
     if (files.length > 0) {
@@ -968,9 +992,8 @@ export function planRerun(events, surfaceNodes, request) {
   // back. When the prompt never lands (admission failed), the walk falls back
   // to the rerun turn's own `turn/start`, so the copies reproduce the whole
   // window and the context keeps its content.
-  const lastShadowed = shadowed[shadowed.length - 1]
-  let logTo = lastShadowed
-  for (let seq = lastShadowed + 1; ; seq += 1) {
+  let logTo = windowHi
+  for (let seq = windowHi + 1; ; seq += 1) {
     const event = bySeq.get(seq)
     if (event === undefined) break
     if (isSurfaceEvent(event)) break
@@ -986,9 +1009,15 @@ export function planRerun(events, surfaceNodes, request) {
     turn,
     targetSeq: target.seq,
     promptSeq: livePromptSeq,
+    // 宿主按**表面位置**遮蔽：range 的两个端点必须本身在表面上，区间内（表面顺序）
+    // 的节点被一起替换。所以端点取窗口的首尾表面节点，而不是 seq 最小/最大——edit
+    // 载体 seq 靠后但槽位在前，拿 seq 当端点会被宿主拒绝（`start seq 13 not found`）。
     startSeq: shadowed[0],
     endSeq: shadowed[shadowed.length - 1],
     shadowed,
+    retired: retiredList,
+    // 客户端在生成期间额外隐藏的行：只含“提示词槽位载体”的直接替换目标。
+    restored,
     // The seq where the replay's copies start in the normal path - the next
     // turn's own bracket - and the fallback start (the rerun turn's bracket)
     // for the failed-admission replay. `rerunTurnEnd` closes the rerun turn;
@@ -1222,7 +1251,11 @@ export function buildShadowWrites(
       type: 'user/message',
       surfaceOp: { op: 'replace', startSeq: plan.startSeq, endSeq: plan.endSeq },
       // 写入前规范化：嵌套数组/重复项/非整数都会让宿主的严格校验器拒绝整条事件。
-      sourceEventSeqs: normalizeShadowed(plan.shadowed),
+      // 引用 = 将要退役的全部事件：窗口里的表面节点 + 被 edit 载体顶掉的原消息
+      // （客户端据此把原文行一起隐藏，不会在 rerun 期间闪回旧提示词）。
+      // 重放用的是 foldSurface 算出的真实遮蔽槽位，不读这个列表，所以多出来的
+      // 原消息不会被复制第二遍。
+      sourceEventSeqs: normalizeShadowed(plan.retired ?? plan.shadowed),
       data: {
         id: randomUUID(),
         role: 'user',
@@ -1376,30 +1409,142 @@ export function buildReplayWrites(events, plan, baseTurn, rerunId, startSeq, pro
   const shadowedSet = new Set(plan.shadowed)
   const editPatches = editPatchesOf(events)
   const turnOf = turnIndex(events)
+  // A replacement carrier (an edit rewriting a turn's prompt) is appended AFTER
+  // the turn closed, so the bracket walk has no turn for it. Its slot belongs to
+  // the original it replaced: follow the chain to the original and read ITS turn.
+  const carrierTargets = new Map()
+  for (const replacement of foldSurface(events).replacements) carrierTargets.set(replacement.seq, replacement.shadowed)
+  const turnFor = (seq) => {
+    const own = turnOf.get(seq)
+    if (typeof own === 'number') return own
+    const seen = new Set([seq])
+    let queue = [...(carrierTargets.get(seq) ?? [])]
+    while (queue.length > 0) {
+      const next = queue.shift()
+      if (seen.has(next)) continue
+      seen.add(next)
+      const turn = turnOf.get(next)
+      if (typeof turn === 'number') return turn
+      queue = queue.concat(carrierTargets.get(next) ?? [])
+    }
+    return undefined
+  }
   const shadowedTurns = new Set()
   for (const seq of plan.shadowed) {
-    const turn = turnOf.get(seq)
+    const turn = turnFor(seq)
     if (typeof turn === 'number') shadowedTurns.add(turn)
   }
-  const included = (event) => {
-    if (isSurfaceEvent(event)) return shadowedSet.has(event.seq)
-    if (
-      event.type === 'turn/start' ||
-      event.type === 'turn/end' ||
-      event.type === 'step/start' ||
-      event.type === 'step/end' ||
-      event.type === 'tool/call'
-    ) {
-      return typeof event.data.turn === 'number' && shadowedTurns.has(event.data.turn)
+  // 按**表面顺序**重放。表面顺序与日志顺序不是一回事：替换事件占的是被替换节点的
+  // 槽位，它的 seq 却更大（edit 把第 2 轮提问改在 seq 33，而它那条回复是 seq 30），
+  // 按日志顺序复制会把「回复数字4」排到它自己那条回复的后面，模型看到的消息顺序就
+  // 变了。这里按 turn → 轮级消息（user）→ step → step 内消息（assistant/tool）
+  // 的槽位顺序排列，括号事件取原日志里的那一条（没有就合成一条）。
+  const bySeq = eventIndex(events)
+  // Which turns the replay copies: the rerun turn's own content is replaced by the
+  // fresh answer, so the normal path starts at the NEXT turn; when the prompt never
+  // landed (fallback) the whole window, rerun turn included, is copied. A caller
+  // that hands us a trimmed plan without `turn` (the replay task re-reads it from
+  // the carrier) still works: the walk start names the first copied turn.
+  const rerunTurn = typeof plan.turn === 'number' ? plan.turn : null
+  const walkTurn = typeof plan.logFrom === 'number' ? turnOf.get(plan.logFrom) : undefined
+  const copyFromTurn =
+    rerunTurn !== null
+      ? promptCopied === true
+        ? rerunTurn
+        : rerunTurn + 1
+      : typeof walkTurn === 'number'
+        ? walkTurn
+        : -Infinity
+  // Where each surface event sits in the log's bracket tree: a user message written
+  // inside a step belongs to that step; a replacement carrier appended after the
+  // turn closed belongs to the turn (it stands in a slot inside it).
+  const placement = new Map()
+  {
+    let openTurn = null
+    let openStep = null
+    for (const event of events) {
+      if (event.type === 'turn/start') {
+        openTurn = event.data.turn
+        openStep = null
+        continue
+      }
+      if (event.type === 'turn/end') {
+        openTurn = null
+        openStep = null
+        continue
+      }
+      if (event.type === 'step/start') {
+        openStep = event.data.step
+        continue
+      }
+      if (event.type === 'step/end') {
+        openStep = null
+        continue
+      }
+      if (!isSurfaceEvent(event)) continue
+      placement.set(event.seq, { turn: openTurn, step: openStep })
     }
-    return false
   }
-  const range = []
-  const bySeq = eventIndex(events)
-  for (let seq = plan.logFrom; seq <= plan.logTo; seq += 1) {
+  const placeOf = (seq) => {
+    const placed = placement.get(seq)
+    if (placed !== undefined && typeof placed.turn === 'number') return placed
+    return { turn: turnFor(seq), step: null }
+  }
+  const buckets = new Map()
+  for (const seq of plan.shadowed) {
     const event = bySeq.get(seq)
     if (event === undefined) continue
-    if (included(event)) range.push(event)
+    const place = placeOf(seq)
+    if (typeof place.turn !== 'number' || place.turn < copyFromTurn) continue
+    let bucket = buckets.get(place.turn)
+    if (bucket === undefined) {
+      bucket = { level: [], steps: new Map() }
+      buckets.set(place.turn, bucket)
+    }
+    if (place.step === null) {
+      bucket.level.push(event)
+    } else {
+      const list = bucket.steps.get(place.step)
+      if (list === undefined) bucket.steps.set(place.step, [event])
+      else list.push(event)
+    }
+  }
+  const bracketOf = (type, turn, step) =>
+    events.find(
+      (event) =>
+        event.type === type &&
+        event.data !== null &&
+        event.data !== undefined &&
+        event.data.turn === turn &&
+        (step === undefined || event.data.step === step),
+    )
+  const callIdsOf = (turn, step) =>
+    events.filter(
+      (event) =>
+        event.type === 'tool/call' &&
+        event.data !== null &&
+        event.data !== undefined &&
+        event.data.turn === turn &&
+        event.data.step === step,
+    )
+  const pushWithCalls = (event, turn) => {
+    range.push(event)
+    if (event.type !== 'assistant/message') return
+    const step = event.data !== null && event.data !== undefined && typeof event.data.step === 'number' ? event.data.step : null
+    if (step === null) return
+    for (const call of callIdsOf(turn, step)) if (!range.includes(call)) range.push(call)
+  }
+  const range = []
+  for (const turn of [...buckets.keys()].sort((left, right) => left - right)) {
+    const bucket = buckets.get(turn)
+    range.push(bracketOf('turn/start', turn) ?? { type: 'turn/start', data: { turn } })
+    for (const event of bucket.level) pushWithCalls(event, turn)
+    for (const step of [...bucket.steps.keys()].sort((left, right) => left - right)) {
+      range.push(bracketOf('step/start', turn, step) ?? { type: 'step/start', data: { turn, step } })
+      for (const event of bucket.steps.get(step)) pushWithCalls(event, turn)
+      range.push(bracketOf('step/end', turn, step) ?? { type: 'step/end', data: { turn, step } })
+    }
+    range.push(bracketOf('turn/end', turn) ?? { type: 'turn/end', data: { turn, reason: { kind: 'completed' } } })
   }
   // Tool pairing facts for the whole range, so assistant content can be
   // corrected before anything is written.
@@ -2324,6 +2469,9 @@ async function applyRerun(ctx, sessionId, body, config) {
     rerunId,
     carrierSeq: plan.startSeq,
     shadowed: plan.shadowed,
+    // 客户端在生成期间要额外隐藏的行：只含提示词槽位那条载体的**直接**替换目标
+    // （即 edit 的原文）。多跳链上的其它目标属于别的轮次，隐藏它们会把界面清空。
+    retired: plan.restored ?? [],
     turn: plan.turn,
     promptSeq: plan.promptSeq,
     ...flush,

package/src/vendor/versions.json

@@ -1,6 +1,6 @@
 {
-  "dsh-edit-turn": "0.5.12",
-  "dsh-rerun-turn": "0.2.6",
-  "dsh-delete-turn": "0.1.15",
+  "dsh-edit-turn": "0.5.13",
+  "dsh-rerun-turn": "0.2.7",
+  "dsh-delete-turn": "0.2.0",
   "dsh-markdown-bubble": "0.1.5"
 }