dsh-client-ui-quote 0.10.0 → 0.11.1

package/README.md

@@ -16,8 +16,9 @@
 | **引用清单** | 右侧栏的一个**页面**：本会话发出去的引用与评论的清单。搜索框按引用/评论过滤、点一条跳回原文、`导出 Markdown` 落一个文件、历史没读完时可 `加载更早的消息`。它作为**页面类型**注册进右侧栏（`ctx.sidebarRightTabs.register`），并在指南页留下一个胶囊作入口；`Alt+L` 同样能打开。数据来自会话自己的事件日志（`ctx.sessions.retain` → `session.eventSource`），不依赖屏幕上有没有那条消息。 |
 | **侧边线程回流** | 同一个页面底部是这条会话的**侧边线程**：显示它最后问的那个问题与消息条数，并给两个动作——**`带回主会话`** 把线程最后「问题 + 答案」写成主会话输入框里的草稿（**不发送**，你自己按发送），**`导出 Markdown`** 把整条线程落成一个文件。线程内容同样从它自己的事件日志读；没有线程时这一节只说明「还没有侧边线程」。 |
 | **改这条引用** | 悬停卡片里的 `改这条引用`：把那条引用当初的**引用与评论都原样放回评论框**（引用正文、评论各占一个输入框，都能改），你改完按 `⏎` 就发出一条**新的**引用（DSH 没有编辑已发送消息的 API，这是唯一诚实的做法）。旧胶囊随即挂上 **`已修订`** 标记，卡片里直接显示改后的评论；**连正文一起改过的**，卡片里也把改后的原文亮出来。标记按引用原文记在本机，跨刷新仍在。 |
+| **逐条回应** | 评论框里的一格**勾选项**（默认关）：勾上，这条引用的块尾就多一行**只有模型读得到的指令**——请按出现顺序把引用记为「引用1」「引用2」…并在回复中逐条对应。模型的回复里每个 `「引用N」` 会变成一枚**小徽章**：悬停就是那条引用的完整卡片（含 `跳回原文` 与 `改这条引用`），点了就跳；编号超出这条消息引用数的标签保持纯文本。指令行与围栏一样只是**线上形态**，胶囊、卡片、导出里都不出现。 |
 - 引用以 DSH 原生行内原子节点 `reference-chip` 插入（带图标的胶囊）；走「评论」时评论一起放进这颗芯片（芯片标签显示为 `引用摘要 · 评论摘要`），引用与评论始终是一体，草稿里不会散成两段。
-- **从文件预览或终端划选的引用是代码**：线格式不再是纯块引用，而是 `> ❝ ``` ` / `> 代码行` / `> ``` ` —— 模型看到的是真正的围栏代码块；胶囊与悬停卡片随之换等宽字体、按代码的空白排版，引用清单导出时也落成 ``` 围栏而非 `>`。围栏只是线格式（传输时剥掉），胶囊上显示的仍是原始代码文本；正文里本身就有 ``` 时改用 `~~~` 围栏。
+- **从文件预览或终端划选的引用是代码**：线格式不再是纯块引用，而是 `> ❝ ``` ` / `> 代码行` / `> ``` ` —— 模型看到的是真正的围栏代码块；胶囊与悬停卡片随之换等宽字体、按代码的空白排版，引用清单导出时也落成 ``` 围栏而非 `>`。围栏只是线格式（传输时剥掉），胶囊上显示的仍是原始代码文本；正文里本身就有 ``` 时改用 `~~~` 围栏。**文件预览的引用还带着它出自哪个文件、哪些行**：宿主标了路径（预览头部的路径标签，或 DOM 上的路径属性）时就写进围栏的信息位——`> ❝ ``` src/app.ts#L12-L48`；预览按行渲染时连行号一起带上（GitHub 的 `#L` 写法）。模型由此可以直接打开这个文件、翻到这几行动手，清单导出的围栏行同样带着它；探测不到就维持原样，什么也不损失。
 - **引用正文可以编辑**：评论框上半格是引用自己的输入框（评论在下半格），划选带进了提示符噪音或多选了几行，当场裁掉再发；「改这条引用」时旧正文回填同一格，改完随新引用发出。
 - 发送时由 DSH 回调本插件取「模型形态」：**`> ❝ …` 引用行 + 同一个块里的 `> ❞ …` 评论行**。消息里那段块会被就地换成 Kimi 那样的一颗胶囊
   （`❝ 引用摘要 │ 评论摘要`，鼠标移上去就能读到引用与评论的全文、点开可展开、悬停出现 `复制`），你自己写的话保持原样，模型收到的仍是完整引用文本。
@@ -52,18 +53,23 @@ DSH 会把包记进 profile 的依赖并加入组合包列表，装完在侧边
       name: dsh-client-ui-quote
 ```
 
-### 方式三：npm 包（发布通道已就位，待 NPM_TOKEN）
+### 方式三：npm 包（已上架）
 
-`package.json` 已经是可发布状态：`private` 已移除、`files` 白名单只带 `lib` / `locale` / `test` / `icon.svg` / `cordis.patch.yml` / 文档，`prepublishOnly` 会在发布前跑完 253 项离线断言，`npm pack --dry-run` 可核对内容（0.10.0 = 14 个文件 / 97.6 kB）。
+已发布到 npm：`dsh-client-ui-quote@0.11.1`（0.10.0 起上架）。发布由 GitHub Actions 完成（`.github/workflows/publish.yml`）：推 `v*` 标签或手动 Run `publish` workflow，`prepublishOnly` 的 290 项断言会先在 runner 上跑完，任何一项失败都不会发出去。`npm pack --dry-run` 可核对内容（0.10.0 = 14 个文件 / 97.6 kB）。
 
-**发布有两条路**（都只差一个 npm Access Token）：
+装：
 
-1. **GitHub Actions（推荐）**：`.github/workflows/publish.yml` 已就位——往仓库里配一个 secret `NPM_TOKEN`（npmjs.com → Access Tokens → Generate New Token，选 **Automation** 类型；或 `gh secret set NPM_TOKEN --repo BangBang-03/dsh-client-ui-quote`），然后推 `v*` 标签或在 Actions 页手动 Run workflow 即发布。之后的版本：改版本号 → 打 `vX.Y.Z` 标签推上去，发布全自动。
-2. **本机 npm**：`npm login && npm publish`——注意本机直连 `registry.npmjs.org` 不可达（系统 DNS 返回污染地址、真实 Cloudflare IP 也握手超时），要挂一个能通 npmjs 的代理再发。
+```bash
+dsh plugin --profile desktop add dsh-client-ui-quote
+```
 
-装：`dsh plugin --profile desktop add dsh-client-ui-quote`。npmjs 侧发布后 npmmirror 一般 10 分钟内同步，DSH 若配置了镜像源即可国内直装。
+npmjs 上架后 npmmirror 一般 10 分钟内同步，DSH 配置了镜像源即可国内直装。
 
-在那之前请用方式一或方式二。
+**发布运维备忘**（给未来的自己）：
+
+- 发布用的是 90 天期 granular token（勾选 **Bypass 2FA**——npm 2026-08 起强制 CI 直发必须带这个标记），**2027-01-09 到期**。到期前重签：npmjs.com → Access Tokens → Generate New Token → Granular → 勾 Bypass 2FA、Read and write (publish and stage)、All packages、90 days → 生成后 `gh secret set NPM_TOKEN --repo BangBang-03/dsh-client-ui-quote`（gh 需已登录）。
+- npm 对**新账号的首包**有安全审核 hold：发布成功后包页会短暂显示 `0.0.0-stage` 占位，属于正常现象，审核自动放行（本包 0.10.0 实测约 1 小时内过审），无需人工操作。
+- npm 官方的长期方向是 Trusted Publishing（OIDC 直发）：2027-01 废弃 bypass-2FA 直发之前，建议在包 Settings → Trusted Publisher 登记 `BangBang-03/dsh-client-ui-quote` + `publish.yml`，并在 workflow 里加 `id-token: write` 权限与 `--provenance` 参数。
 
 ### 卸载
 
@@ -73,7 +79,7 @@ DSH 会把包记进 profile 的依赖并加入组合包列表，装完在侧边
 
 1. 在会话正文、**文件预览**或**终端**里**拖动选中**一段文字（后两者没有自己的会话 id，引用会落进当前屏幕上那条会话，并且以**围栏代码块**的线格式发给模型；输入框内的选区属于改稿，不触发）。
 2. 选区**下方**浮出浮层（下方空间不够时才改到上方），选择 **评论**、**添加到对话** 或 **侧边对话**。同一组动作也有键位：**`Alt+Q`** 直接引用、**`Alt+C`** 直接开评论框、**`Alt+B`** 直接开侧边对话（都在设置里可改；没有选区时按键原样让给其它快捷键）。
-3. 前两个动作把引用放进输入框（评论模式下引用与评论在同一颗芯片里；**评论框上半格是引用正文本身，可以当场裁剪**），页面选区被清除、焦点交给输入框，可以接着写正式提问。
+3. 前两个动作把引用放进输入框（评论模式下引用与评论在同一颗芯片里；**评论框上半格是引用正文本身，可以当场裁剪**；评论框里还有一格 **`让模型逐条回应`** 勾选项，勾上这条引用就带着逐条指令发出去），页面选区被清除、焦点交给输入框，可以接着写正式提问。
 4. **侧边对话**写的是另一条会话的输入框：右侧栏打开该线程的页签（标题取引用首行），引用以纯块引用形态落在它的草稿里，**不发送**；你接着在这条线程里写自己的问题、自己按发送。同一条主会话只会有一条侧边线程，第二次点第三项就把新引用接在草稿后面。同一会话上一次请求还在进行时，再次点击会并入第一次，不会开出两条重复线程。
 5. 浮层收起条件：单击别处、选区清空、按 `Esc`、滚动会话、窗口尺寸变化，以及动作完成之后。双击选词不会把浮层关掉。
 6. 发送出去以后，消息里那段块会显示成一颗**胶囊**：收起时是单行 `❝ 引用摘要 │ 评论摘要`，**鼠标移上去**会浮出一张卡片显示完整的引用与评论
@@ -129,6 +135,12 @@ DSH 的输入框是 Lexical，没有 Kimi 的 `quote` 节点，但有一个通
     模型读到块引用里一个真正的围栏代码块；`splitQuoteRuns` 解析时把首行的围栏（和收尾那一行）剥掉，胶囊拿到的仍是原始代码文本，
     渲染加 `data-code="true"`（等宽、`pre`、展开时横向滚动），卡片加 `dshq-pop-code`，侧边对话落进子线程草稿的则是不带标记的裸围栏；
     正文本身含 ``` 时序列化自动换 `~~~` 围栏。没有围栏的块照旧按普通引用解析，新旧消息互不影响；
+    **预览引用的文件路径与行号**走的是围栏自带的信息位（`> ❝ ``` src/app.ts#L12-L48`）——Markdown 里这本来就是「渲染器不显示、模型读得到」的位置，
+    `sanitizePath` 把带空白/围栏字符的伪路径挡掉。探测按两种宿主形状来：先在预览根（`[data-document-preview]`）里找宿主自己的路径标签
+    （`[data-textpreview-path]`，完整路径在它的 `title` 里——标签在头部，与选区所在的 body 是兄弟分支），再退回「宿主或其祖先上的路径属性」；
+    行号取自 `data-textpreview-line` 标记的行元素（`withLineRange` 拼成 GitHub 的 `#L` 写法，起止顺序自动归一）。两种都没命中就原样发；
+  - **逐条回应的指令行**同样只是线上形态：勾了评论框里的开关，块尾多一行 `> ※ 指令：…`，`splitQuoteRuns` 按 `※ 指令` 前缀把它从块里剥掉，
+    所以胶囊、卡片、清单导出全都看不到它（用户自己的评论/引用恰好以 `※ 指令` 开头的概率，比它带来的清晰收益小得多，已记入已知限制）；
   - 客户端插件用 `MutationObserver` 找「只含一个文本子节点、内部有 `❝`、位于 `[data-conversation-content]` 里」的那个 run，
     把整条消息拆成 `前文 / 引用 / 中间文字 / 引用 / 后文` 这样一串分段（`splitQuoteRuns`），给原 run 加 `display:none`，
     在它**前面**按顺序插入自己的元素：每段引用一颗胶囊，每段用户自己的话一个 `span.dshq-body`（保持 `pre-wrap`）——
@@ -147,6 +159,15 @@ DSH 的输入框是 Lexical，没有 Kimi 的 `quote` 节点，但有一个通
     卡片跟着锚点活：锚点一旦离开文档（发消息会把芯片拿走，而被移除的节点不会再发 `mouseleave`）卡片立刻收起，
     React 重渲染换掉胶囊时同理 —— 不会留下一张浮在空处的卡片。
 
+### 逐条回应的回复徽章
+
+指令行只是让模型**肯按编号回答**；让回答**连得回来**的是另一套覆盖层。模型按指令把每条回应标成 `「引用1」…「引用N」` 之后：
+
+- 徽章增强器在**同一条会话面板**里找这条回复之前**最近的一条带胶囊的消息**（一次树序遍历同时解决「最近」和「在前」：走到徽章文本节点之前最后记账的那条 run 就是它），把它发出去的引用按顺序编号——第 N 颗胶囊就是「引用N」。
+- 回复文本里的 `「引用N」` 于是被切成一枚 `span.dshq-ref` 徽章（**原文一个字不改**，只是套上底色和悬停行为）；编号超出那条消息引用数的标签（模型数错了，或有人在正文里自己写了「引用1」）保持纯文本——一枚点了没反应的徽章比没有徽章更糟。
+- 徽章复用悬停卡片：`mouseenter` 就是那张卡（引用、评论全文，`跳回原文` 与 `改这条引用` 按坐标有无自动出现），点击等同清单页里点一行——有坐标就跳，没坐标无声。切分文本节点比胶囊那套「只隐藏、再旁边画」更进一步，规则也补得更紧：一个文本节点只切一次（账本记着原文）；React 重写了文本（值不再是账本里的首块）就整体撤掉重切；卸载时原文放回。这层只挂在**助手消息**的文本上——用户自己消息里的「引用1」是草稿的一部分，谁也不该动。
+- 侧边线程（第三项）的围栏同样带路径（``` src/app.ts 的裸围栏），子线程的模型由此也知道代码出自哪个文件。
+
 ### 侧边对话（第三项）
 
 第三项是本插件自己的扩展（Kimi 的浮层只有两项），融合了三家 agent 同类组件的优点：**Kimi Code 的 `/btw` 侧边聊天**——一键在侧边栏开一条继承主会话上下文的线程；**Qoder 的「在侧边任务中提问」**——同一会话进行中的创建请求自动并入第一次，失败只弹一条提示，绝不大张旗鼓；**WorkBuddy 的划选引用**——引用是线程里持久的内容，而不是一次性的草稿附件。与前两家不同的是**问什么由你来写**：引用只落进那条线程的输入框，不会被当成第一条消息替你发出去。样式上第三项用 DeepSeek 的鲸鱼蓝（`#4d6bfe`）画图标与悬停色，白底浅色主题是主基调，深色主题同一色相。
@@ -206,7 +227,7 @@ transcript 侧的 `.dshq-cap` 胶囊：一颗胶囊同时装引用与评论，`
 1. **语义而不是机制**：引用与评论是同一颗节点（对齐 Kimi 的 `quote` 节点 `{text, comment}`），一颗芯片 → 一个块 → 一颗胶囊 → 一张卡片 → 一次复制；机制（reference chip、DOM 增强）谁都能抄，这条链子不好抄。
 2. **引用是带坐标的活对象**：`跳回原文` 在自己的会话面板里找行、按宿主的方式对齐到 24px，行被虚拟列表藏起来或没挂载都能找回来；坐标不随引用文本发给模型（不污染 prompt）。
 3. **引用有下落**：清单页（搜索 / 跳转 / 导出 Markdown）+ 侧边线程回流（结论写回主会话草稿 / 导出线程），这两件事在 4471 条里没有对应物。
-4. **工程化**：253 项离线断言（含真跑 `sessions.retain` / `setDraft` / 下载链路）、每个宿主契约都在 README 里写明出处、每个版本都有可回读的 release。同类里多数是一两百行、没有测试的插件。
+4. **工程化**：290 项离线断言（含真跑 `sessions.retain` / `setDraft` / 下载链路）、每个宿主契约都在 README 里写明出处、每个版本都有可回读的 release。同类里多数是一两百行、没有测试的插件。
 
 反过来也要说清楚：**本插件不做的**——不做翻译/解释类选区动作（81 条同类在做）、不做多选合并引用（7 条有）、不做选区折叠/行内 diff 这类渲染花样。它只把「引用」这一件事做穿。
 
@@ -239,8 +260,8 @@ locale/zh.json        插件页卡片文案（中文）
 locale/en.json        插件页卡片文案（英文）
 test/check.mjs        离线自检（清单 + 组件契约）
 test/dom.mjs          给离线自检用的最小 DOM / MutationObserver 垫片
-test/capsule.mjs      离线自检（发送后胶囊 + 悬停卡片 + 跳回原文 + 键位 + 改这条引用 + 代码引用，159 项断言）
-test/panel.mjs        离线自检（引用清单：解析 / 搜索 / Markdown / 读取 / 导出 / 页面注册 + 侧边线程回流，94 项断言）
+test/capsule.mjs      离线自检（发送后胶囊 + 悬停卡片 + 跳回原文 + 键位 + 改这条引用 + 代码引用 + 文件路径 + 逐条回应的回复徽章，194 项断言）
+test/panel.mjs        离线自检（引用清单：解析 / 搜索 / Markdown / 读取 / 导出 / 页面注册 + 侧边线程回流，96 项断言）
 test/capsule.html     真浏览器里跑同一套胶囊断言（可选）
 ```
 
@@ -287,10 +308,10 @@ React 重渲染不会出现第二颗、引用变了就地重建、消息被删
 卡片给出 `跳回原文` 与 `改这条引用` 两个动作、点后者把栏切到评论模式并**预填旧评论与旧正文**、
 按确认后 `insertReference` 恰好一次（新芯片的 `ref` 带改后的评论）、旧引用被记为「已修订」并落进 `localStorage`、
 旧胶囊挂上 `已修订` 徽标、它的卡片显示改后的评论（连正文改过的连改后原文一起显示）、空修订不算修订、
-修订不改写引用原文本身、清空引用正文时确认按钮禁用、改后的正文随新芯片发出（共 159 项）。
+修订不改写引用原文本身、清空引用正文时确认按钮禁用、改后的正文随新芯片发出（共 194 项，含文件路径与逐条回应的线上形态、回复徽章的建立/重建/卸载与悬停卡片复用）。
 `test/capsule.html` 是同一套断言的真浏览器版，用 `file://` 打开即可（页面会把结果写进标题与 `#probe-out`）。
 
-`test/panel.mjs` 单独跑引用清单页与侧边线程回流（94 项）：只认**持久**的 `user/message`（`transient`、助手消息、`data: null` 都跳过）、
+`test/panel.mjs` 单独跑引用清单页与侧边线程回流（96 项）：只认**持久**的 `user/message`（`transient`、助手消息、`data: null` 都跳过）、
 引用按原文逐行拆出来而评论跟着同一条记录、最新一条排最前、空查询保持全量、引用与评论都能被搜到且忽略大小写、
 Markdown 的标题/编号/块引用/评论行/时间戳与空列表兜底、超长引用在标题里被截断、非法时间导出为空；
 读取侧用桩 `sessions.retain` 真跑一遍——读出两行且 `hasMore` 透传、**读完必须 release**（记录 `source: "quoteList"`）、
@@ -306,7 +327,7 @@ Markdown 的标题/编号/块引用/评论行/时间戳与空列表兜底、超
 `bringThreadBack` 把结论写成**草稿**（原有草稿保留、空行隔开）、外壳没有 `setDraft` 时如实失败、没有线程时不乱写；
 `exportThread` 的文件名与整条线程内容、以及 MIME 是 Markdown。
 
-合计 **253 项**（check.mjs 的契约断言 + capsule 159 + panel 94），`npm test` 全绿。
+合计 **290 项**（check.mjs 的契约断言 + capsule 194 + panel 96），`npm test` 全绿。
 
 ## 已知限制
 
@@ -318,6 +339,9 @@ Markdown 的标题/编号/块引用/评论行/时间戳与空列表兜底、超
   线程创建要求父会话处于运行态（历史归档会话会收到 409，同样落 toast）。
 - **「改这条引用」是追加，不是原地编辑**：DSH 的 transcript 只追加（侦察确认全树没有 `editMessage` / `updateMessage` / `rewriteMessage` / 回收 API，只有**尚未进入会话**的队列条目可改）。所以修订发出一条新引用（评论、引用正文都可改），旧胶囊只挂 `已修订` 标记——标记存在**本机** `localStorage`（`dsh-client-ui-quote:v1:quote-revised`，按引用原文归一键、上限 60 条），因此不会跨标签页、跨设备同步，也不进入模型上下文；模型看到的是那条改后的新引用。正文改过后键仍是旧原文：`已修订` 挂在**旧**胶囊上（它的卡片里显示改后的原文与评论），改后的新胶囊不挂标。
 - **代码引用的识别靠首行围栏**：`> ❝ ``` ` 开头的块按代码解析（围栏剥掉、胶囊等宽）。因此一条**普通**引用如果正文恰好以 ``` 或 `~~~` 开头（比如在 Markdown 文件预览里引用了源码），回读时也会被当成代码引用——显示上是等宽排版，文字不丢。
+- **逐条回应的指令行按 `※ 指令` 前缀剥离**：剥离规则收得很窄，但一条引用或评论如果恰好以 `※ 指令` 开头，回读时那一行会被当成指令剥掉（胶囊里看不到它）。要让这样的内容活着，别勾逐条回应即可——指令行只在勾选时才写入。
+- **文件预览的路径与行号是探测来的**：路径优先读宿主预览头部的路径标签（`[data-textpreview-path]` 的 `title`，实测 0.2.0-rc.2 的侧栏文档预览就是这个形状），其次探一组候选属性；行号只在预览按行渲染时可得（`data-textpreview-line`，纯文本视图有、高亮代码视图没有）。两者都拿不到就不带（引用形态与从前完全一样）；终端来源的引用没有路径可言。路径与行号写进围栏信息位，`sanitizePath` 把带空白或围栏字符的值挡掉。
+- **回复徽章依赖模型守格式**：模型没按指令输出 `「引用N」` 就没有徽章——无损，只是少了联动；输出越界的编号（数错了）保持纯文本。徽章的编号以回复**之前最近的一条带胶囊的消息**为准；切分的是助手消息的文本节点，DSH 若改了助手消息的渲染形态，徽章增强器要跟着调（与胶囊的 `isQuoteRun` 同一条既有限制）。
 - 依赖 DSH 客户端的内部接口（`conversation.input.overlay` 槽位、`inputTriggers.registerSource`、`conversation.input.shell(id).insertReference`、
   `reference-chip` 节点），DSH 升级有可能失效。
 - **引用清单页依赖右侧栏的两个服务**（`sidebarRightTabs` 与 `sidebarRight`，实测 0.2.0-rc.2）；宿主没有它们时页面不注册、`Alt+L` 给一条 toast
@@ -355,3 +379,8 @@ and it closes with the chip as soon as the message is sent. Each chip resolves i
 reuses a chip node for the next quote, so a card can never show the previous one's text.
 Install with `dsh plugin --profile desktop add link:<clone-path>` (DSH >= 0.2.0-rc.2, web/desktop client).
 Test with `npm test`. MIT licensed.
+
+Two wire-only extras ride on the same pipeline: a per-quote reply toggle in the comment box (the block carries a
+transport-only instruction, the model answers `「引用N」` by `「引用N」`, and each label becomes a badge that reopens
+the quote's hover card), and a preview quote that puts its file into the fence's info string so the model can open
+the file itself.

package/lib/client.js

@@ -83,7 +83,8 @@ window.__ModuleLoader__.load({
 			threadBackFailed: "没读到这个线程的内容",
 			threadCount: "{n} 条消息",
 			revise: "改这条引用",
-			revised: "已修订"
+			revised: "已修订",
+			replyToggle: "让模型逐条回应"
 		};
 
 		/** English copy, verbatim from Kimi Code's `selection` namespace. */
@@ -119,7 +120,8 @@ window.__ModuleLoader__.load({
 			threadBackFailed: "Could not read that thread",
 			threadCount: "{n} messages",
 			revise: "Revise this quote",
-			revised: "Revised"
+			revised: "Revised",
+			replyToggle: "Ask for per-quote replies"
 		};
 
 		/* ------------------------------------------------------------------ *
@@ -150,6 +152,35 @@ window.__ModuleLoader__.load({
 		 */
 		const COMMENT_MARK = "\u275E";
 
+		/**
+		 * The mark that opens the transport-only reply instruction line. When the
+		 * comment box's 逐条回应 toggle is on, the block ends with one more
+		 * blockquote line starting with this mark; the model reads it and answers
+		 * per quote (`「引用1」…「引用N」`), while `splitQuoteRuns` strips the line
+		 * on the way back out — a capsule, a card and the export never show it.
+		 * The `指令：` phrase after the mark is part of the strip rule, so a line
+		 * that happens to start with a bare `※` is left alone.
+		 */
+		const REPLY_MARK = "\u203B";
+		const REPLY_INSTRUCTION =
+			"指令：请把本条消息里的引用块按出现顺序记为「引用1」「引用2」…，回复时逐条对应回应，每条回应前标注「引用N」。";
+
+		/**
+		 * Attributes a file preview may carry its path in. The preview DOM is a
+		 * host detail this plugin does not own, so the lookup walks a few ancestors
+		 * and takes the first hit; when none matches, the quote travels without a
+		 * path — exactly the shape it had before the probe existed.
+		 */
+		const PREVIEW_PATH_ATTRS = [
+			"data-textpreview-path",
+			"data-preview-path",
+			"data-document-path",
+			"data-file-path",
+			"data-path",
+			"data-file",
+			"data-filename"
+		];
+
 		/** Transcript host: a selection outside it is none of our business. */
 		const CONTENT_SELECTOR = "[data-conversation-content]";
 		/** The composer card: a selection inside it is a draft edit, not a quote. */
@@ -300,6 +331,10 @@ background:transparent;color:inherit;font:inherit;cursor:default}
 #${BAR_ID} .dshq-btn-primary:hover{background:var(--dshq-accent);opacity:.9}
 #${BAR_ID} .dshq-btn:disabled{opacity:.45}
 #${BAR_ID} .dshq-enter{margin-left:4px;opacity:.65}
+#${BAR_ID} .dshq-reply{display:flex;align-items:center;gap:6px;font-size:11.5px;line-height:1.5;
+opacity:.78;cursor:pointer;user-select:none}
+#${BAR_ID} .dshq-reply:hover{opacity:1}
+#${BAR_ID} .dshq-reply-check{margin:0;accent-color:var(--dshq-accent,currentColor)}
 #${TOAST_ID}{position:fixed;z-index:2147483001;display:none;padding:4px 10px;border-radius:6px;
 background:rgba(24,24,27,.92);color:#f4f4f5;font-size:12px;line-height:1.5;pointer-events:none;
 -webkit-app-region:no-drag}
@@ -334,6 +369,9 @@ text-overflow:clip;overflow-wrap:anywhere}
 .dshq-cap[data-expanded="true"] .dshq-cap-comment{flex:1 1 100%;max-width:none;margin-top:5px;
 padding-left:9px;white-space:pre-wrap;overflow:visible;text-overflow:clip;overflow-wrap:anywhere}
 .dshq-body{display:block;white-space:pre-wrap;overflow-wrap:anywhere}
+.dshq-ref{display:inline;padding:0 4px;border-radius:6px;cursor:pointer;color:inherit;font-weight:600;
+background:rgba(127,127,127,.12);background:color-mix(in srgb,currentColor 9%,transparent)}
+.dshq-ref:hover{background:rgba(127,127,127,.2);background:color-mix(in srgb,currentColor 16%,transparent)}
 /* Hover card: a collapsed pill keeps one clipped line per half and the chip in
 the composer is clipped even harder, so hovering either one shows the quote and
 the comment in full. It is parked on <body> with position:fixed because a chat
@@ -447,12 +485,83 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		 * ------------------------------------------------------------------ */
 
 		/**
-		 * @returns {{ text: string, x: number, y: number, bottom: number, sessionId: string, hostKind: "chat" | "preview" | "terminal" } | null}
+		 * @returns {{ text: string, x: number, y: number, bottom: number, sessionId: string, hostKind: "chat" | "preview" | "terminal", path: string | null } | null}
 		 *   the selected text plus its viewport anchor, or null when the current
 		 *   selection is not a quotable transcript selection. `hostKind` says where
 		 *   the selection lives: a preview/terminal quote is code and travels in a
-		 *   fenced block, a chat quote stays a plain blockquote.
+		 *   fenced block, a chat quote stays a plain blockquote. `path` is the file
+		 *   a preview selection came from, when the host exposes one.
+		 */
+		/**
+		 * A path is only worth sending when it reads as one: no whitespace (the
+		 * fence info string cannot carry it), no fence characters, not absurdly
+		 * long. Anything else degrades to no path at all.
 		 */
+		function sanitizePath(value) {
+			const path = String(value === null || value === undefined ? "" : value).trim();
+			if (path === "" || path.length > 200 || /\s|[`~]/u.test(path)) return null;
+			return path;
+		}
+
+		/**
+		 * Path + line range as one fence-friendly token. The range rides in
+		 * GitHub's `#L12-L48` spelling — the one shape every developer (and every
+		 * model) already reads. An unusable path costs the whole thing; a missing
+		 * or one-sided range costs only the suffix.
+		 */
+		function withLineRange(path, start, end) {
+			const clean = sanitizePath(path);
+			if (clean === null) return null;
+			const from = Number.isSafeInteger(start) && start >= 1 ? start : null;
+			const to = Number.isSafeInteger(end) && end >= 1 ? end : null;
+			if (from === null || to === null) return clean;
+			if (from === to) return clean + "#L" + from;
+			return clean + "#L" + Math.min(from, to) + "-L" + Math.max(from, to);
+		}
+
+		/**
+		 * The file a preview selection came from, when the host exposes it. Two
+		 * shapes are probed, in order:
+		 *
+		 * 1. The host's own preview root carries a `PathLabel` —
+		 *    `[data-textpreview-path]`, a boolean flag whose element holds the
+		 *    full path in its `title` (and in its text). This is the real shape
+		 *    of the sidebar document preview; the label sits in the header, a
+		 *    sibling of the body the selection lives in.
+		 * 2. A path-shaped attribute on the host or its ancestors — for any other
+		 *    preview host that marks the path as data.
+		 *
+		 * A miss is the normal case for an unknown host and costs nothing: the
+		 * quote then travels exactly as before.
+		 */
+		function previewPathOf(host) {
+			if (typeof host.closest === "function") {
+				// Two plain `closest` calls rather than one comma list: the wire only
+				// ever needs one root, and a comma is one selector-engine feature
+				// the offline shim does not have to grow.
+				const root = host.closest("[data-document-preview]") ?? (host.closest("[data-textpreview-state]") ?? null);
+				if (root !== null && typeof root.querySelector === "function") {
+					const label = root.querySelector("[data-textpreview-path]");
+					if (label !== null) {
+						const title = typeof label.getAttribute === "function" ? label.getAttribute("title") : null;
+						const clean = sanitizePath(typeof title === "string" && title !== "" ? title : label.textContent);
+						if (clean !== null) return clean;
+					}
+				}
+			}
+			let node = host;
+			for (let hop = 0; node !== null && node !== undefined && hop < 6; hop += 1, node = node.parentElement) {
+				if (typeof node.getAttribute !== "function") continue;
+				for (const attr of PREVIEW_PATH_ATTRS) {
+					const value = node.getAttribute(attr);
+					if (typeof value !== "string") continue;
+					const clean = sanitizePath(value);
+					if (clean !== null) return clean;
+				}
+			}
+			return null;
+		}
+
 		function readSelection() {
 			const selection = document.getSelection === undefined ? null : document.getSelection();
 			if (selection === null || selection.rangeCount === 0 || selection.isCollapsed) return null;
@@ -492,6 +601,20 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			const rect = range.getBoundingClientRect();
 			if (rect.width === 0 && rect.height === 0) return null;
 
+			// A preview selection may carry the file it came from — and, when the
+			// host numbers its lines (`data-textpreview-line`), the exact range:
+			// both ride in the fence's info string so the model can open the file
+			// at the very lines it is looking at.
+			let path = null;
+			if (hostKind === "preview") {
+				const lineOf = (node) => {
+					const row = closestFrom(node, "[data-textpreview-line]");
+					const value = row === null ? Number.NaN : Number(row.getAttribute("data-textpreview-line"));
+					return Number.isSafeInteger(value) && value >= 1 ? value : null;
+				};
+				path = withLineRange(previewPathOf(host), lineOf(range.startContainer), lineOf(range.endContainer));
+			}
+
 			return {
 				text,
 				x: rect.left + rect.width / 2,
@@ -499,6 +622,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				bottom: rect.bottom,
 				sessionId,
 				hostKind,
+				path: typeof path === "string" ? path : null,
 				// Only a transcript selection has a row to jump back to.
 				source: chat === null ? null : chatRowOf(range.startContainer)
 			};
@@ -530,8 +654,18 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		 * `> ❝ ``` ` / `> …` / `> ``` ` — so the model sees a real code block
 		 * while the block (and its capsule) still opens at the ❝ mark. The fence
 		 * is transport only: `splitQuoteRuns` strips it again on the way out.
+		 * A preview quote can carry its file the same way: `meta.path` rides in
+		 * the fence's info string (`> ❝ ``` src/app.ts`), which is where Markdown
+		 * keeps metadata the model reads but renderers never show as content.
+		 *
+		 * `meta.reply === true` appends one transport line at the block's tail —
+		 * the 逐条回应 instruction the model answers quote by quote. Like the
+		 * fence it is wire-only: `splitQuoteRuns` strips it before anything
+		 * downstream (capsule, card, export) ever sees it.
 		 */
-		function quoteBlock(text, comment, code) {
+		function quoteBlock(text, comment, code, meta) {
+			const options = meta === null || meta === undefined || typeof meta !== "object" ? {} : meta;
+			const path = sanitizePath(options.path) ?? "";
 			const halves = [
 				{ mark: QUOTE_MARK, lines: blockLines(text) },
 				{ mark: COMMENT_MARK, lines: blockLines(comment) }
@@ -540,7 +674,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			for (const half of halves) {
 				if (code === true && half.mark === QUOTE_MARK && half.lines.length > 0) {
 					const fence = half.lines.some((line) => /^\s*```/u.test(line)) ? "~~~" : "```";
-					block.push("> " + half.mark + " " + fence);
+					block.push("> " + half.mark + " " + fence + (path === "" ? "" : " " + path));
 					for (const line of half.lines) block.push(line.trim() === "" ? ">" : "> " + line);
 					block.push("> " + fence);
 					continue;
@@ -551,6 +685,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 					else block.push(line.trim() === "" ? ">" : "> " + line);
 				}
 			}
+			if (options.reply === true) block.push("> " + REPLY_MARK + " " + REPLY_INSTRUCTION);
 			return block.join("\n");
 		}
 
@@ -594,14 +729,19 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 					body.push(lines[index].replace(/^>\s?/u, ""));
 					index += 1;
 				}
+				// The 逐条回应 instruction is transport for the model: it rides at
+				// the block's tail and never reaches a capsule, a card or the
+				// export. The `指令：` phrase keeps the strip narrow — a quote or
+				// comment that merely starts with a `※` is left alone.
+				const carried = body.filter((entry) => !/^\s*※\s*指令/u.test(entry));
 				const before = loose.replace(/^\s+/u, "").replace(/\s+$/u, "");
 				if (before !== "") segments.push({ type: "text", text: before });
 				loose = "";
 				// `> ❞ …` opens the comment half of the same block: everything from
 				// there down is the comment, everything above it is the quote.
-				const cut = body.findIndex((entry) => entry.replace(/^\s+/u, "").startsWith(COMMENT_MARK));
-				let quoteLines = cut === -1 ? body : body.slice(0, cut);
-				const commentLines = cut === -1 ? [] : body.slice(cut);
+				const cut = carried.findIndex((entry) => entry.replace(/^\s+/u, "").startsWith(COMMENT_MARK));
+				let quoteLines = cut === -1 ? carried : carried.slice(0, cut);
+				const commentLines = cut === -1 ? [] : carried.slice(cut);
 				if (commentLines.length > 0) {
 					commentLines[0] = commentLines[0]
 						.replace(/^\s+/u, "")
@@ -638,9 +778,9 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		}
 
 		/** Quote (+ optional comment) exactly as it should land in the draft. */
-		function buildPayload(text, comment, code) {
+		function buildPayload(text, comment, code, meta) {
 			const prefix = composerText().trim() === "" ? "" : "\n";
-			return prefix + quoteBlock(text, comment, code) + "\n\n";
+			return prefix + quoteBlock(text, comment, code, meta) + "\n\n";
 		}
 
 		/** Kimi inserts at the caret; the composer answers a collapsed span at the end. */
@@ -667,11 +807,11 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		 * comment rides in that same ref, which is what lets the transcript keep
 		 * the pair in one capsule instead of two unrelated pieces of text.
 		 */
-		function chipRef(text, comment, code) {
+		function chipRef(text, comment, code, meta) {
 			// The leading newline puts the block on its own paragraph when the chip
 			// lands after typed text; the send path trims it when the quote is
 			// the whole message.
-			return "\n" + quoteBlock(text, comment, code) + "\n\n";
+			return "\n" + quoteBlock(text, comment, code, meta) + "\n\n";
 		}
 
 		/** The chip label spells the pair out the way Kimi's `display_text` does. */
@@ -729,7 +869,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		 * shell owns the editor that can place an atomic node. Every step is
 		 * optional — a missing service just falls back to the Markdown form.
 		 */
-		function insertChip(entry, sessionId, text, comment, code) {
+		function insertChip(entry, sessionId, text, comment, code, meta) {
 			if (!ensureSource() || pluginCtx === null) return false;
 			let hub = null;
 			try {
@@ -746,7 +886,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				shell = null;
 			}
 			if (shell === null || shell === undefined || typeof shell.insertReference !== "function") return false;
-			const model = chipRef(text, comment, code);
+			const model = chipRef(text, comment, code, meta);
 			const attachment = {
 				source: SOURCE_NAME,
 				ref: model,
@@ -1541,7 +1681,9 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 
 			const parent = run.parentNode;
 			if (parent === null) return;
-			capsules.set(run, { text, nodes });
+			// The segments ride along in the ledger: the reply badges need the
+			// numbered quotes of the nearest preceding capsule-carrying message.
+			capsules.set(run, { text, nodes, segments });
 			run.style.display = "none";
 			for (const node of nodes) parent.insertBefore(node, run);
 		}
@@ -1572,9 +1714,13 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			for (const record of records) {
 				if (record.type === "characterData") {
 					collectRuns(record.target, capsuleDirty);
+					collectRefRuns(record.target, refDirty);
 					continue;
 				}
-				for (const node of record.addedNodes) collectRuns(node, capsuleDirty);
+				for (const node of record.addedNodes) {
+					collectRuns(node, capsuleDirty);
+					collectRefRuns(node, refDirty);
+				}
 				for (const node of record.removedNodes) {
 					if (node.nodeType === 1 && capsules.has(node)) capsuleDirty.add(node);
 				}
@@ -1601,6 +1747,8 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				if (run.isConnected) enhance(run);
 				else if (capsules.has(run)) dropCapsule(run);
 			}
+			// Badges come last: the quotes they link to must be in the ledger first.
+			flushRefBadges();
 			wireChips();
 		}
 
@@ -1626,7 +1774,10 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				capsuleObserver.observe(target, { childList: true, subtree: true, characterData: true });
 			}
 			if (typeof document.querySelectorAll === "function") {
-				for (const host of document.querySelectorAll(CONTENT_SELECTOR)) collectRuns(host, capsuleDirty);
+				for (const host of document.querySelectorAll(CONTENT_SELECTOR)) {
+					collectRuns(host, capsuleDirty);
+					collectRefRuns(host, refDirty);
+				}
 			}
 			// A fixed card would otherwise hang in place after the page moved.
 			if (!popoverWired && typeof window !== "undefined" && typeof window.addEventListener === "function") {
@@ -1649,6 +1800,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			}
 			capsuleDirty.clear();
 			for (const run of Array.from(capsules.keys())) dropCapsule(run);
+			uninstallRefBadges();
 			cancelPopoverHide();
 			unhookChips();
 			if (popover !== null) {
@@ -1668,6 +1820,199 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			}
 		}
 
+		/* ------------------------------------------------------------------ *
+		 * Reply badges — the model's per-quote answers, linked back
+		 * ------------------------------------------------------------------ */
+
+		/**
+		 * The other half of 逐条回应: when the instruction rode along with the
+		 * quotes, the model labels its answers `「引用1」…「引用N」`, and each
+		 * label becomes a badge — hover it and the quote's card opens (jump and
+		 * revise included, exactly as on a capsule), because the reply is only
+		 * useful while it stays tied to the passage it answers.
+		 *
+		 * The label lives inside a markdown-rendered assistant run, so this pass
+		 * splits the text node it sits in — one step more invasive than the
+		 * capsule overlay, which only hides and re-reads whole runs. The rules
+		 * that keep it safe: a text node is split only once (the ledger holds the
+		 * original), a rewrite by React is detected by the value no longer being
+		 * our head chunk (our nodes go, the node is re-read fresh), and uninstall
+		 * puts the original text back. A label whose number outruns the quotes of
+		 * the nearest preceding quoted message is left as plain text — the model
+		 * may miscount, and a dead badge would be worse than no badge.
+		 */
+
+		/** text node -> { text, head, nodes } for every split reply run. */
+		const refBadges = new Map();
+		const refDirty = new Set();
+		const REF_LABEL = /\u300c\u5f15\u7528\d+\u300d/u;
+
+		function isRefCandidate(node) {
+			if (node === null || node.nodeType !== 3) return false;
+			const value = typeof node.nodeValue === "string" ? node.nodeValue : "";
+			if (REF_LABEL.test(value) !== true) return false;
+			const parent = node.parentElement;
+			if (parent === null || typeof parent.closest !== "function") return false;
+			if (parent.closest("[data-dshq]") !== null) return false;
+			return parent.closest(CONTENT_SELECTOR) !== null;
+		}
+
+		/** Gather candidate text nodes out of a mutation's added subtree. */
+		function collectRefRuns(node, into) {
+			if (node.nodeType === 3) {
+				if (isRefCandidate(node) === true) into.add(node);
+				return;
+			}
+			const element = elementOf(node);
+			if (element === null) return;
+			const stack = [element];
+			while (stack.length > 0) {
+				const current = stack.pop();
+				for (const child of current.childNodes) {
+					if (child.nodeType === 3) {
+						if (isRefCandidate(child) === true) into.add(child);
+					} else if (child.nodeType === 1 && child.childNodes.length > 0) {
+						stack.push(child);
+					}
+				}
+			}
+		}
+
+		/**
+		 * The quotes of the nearest preceding capsule-carrying run, in message
+		 * order. One walk over the session host settles both "nearest" and
+		 * "before" — the run that was last seen when the walk reached the badge's
+		 * text node is the one that precedes it.
+		 */
+		function precedingQuoteSegments(node, host) {
+			let best = null;
+			let seen = false;
+			const walk = (current) => {
+				if (seen === true) return;
+				if (current === node) {
+					seen = true;
+					return;
+				}
+				if (capsules.has(current)) best = current;
+				for (const child of current.childNodes) walk(child);
+			};
+			walk(host);
+			if (best === null) return [];
+			const known = capsules.get(best);
+			const segments = known === undefined || known === null ? null : known.segments;
+			if (!Array.isArray(segments)) return [];
+			return segments.filter((segment) => segment !== null && segment !== undefined && segment.type === "quote");
+		}
+
+		function removeRefNodes(known) {
+			if (known === undefined || known === null) return;
+			for (const node of known.nodes) {
+				if (node !== null && node !== undefined && node.isConnected) node.remove();
+			}
+		}
+
+		function refBadgeFor(doc, sessionId, label, segment) {
+			const info = {
+				quote: segment.quote,
+				comment: typeof segment.comment === "string" ? segment.comment : "",
+				sessionId,
+				code: segment.code !== null && segment.code !== undefined
+			};
+			const badge = el(doc, "span", { class: "dshq-ref", "data-dshq": "ref", text: label });
+			badge.addEventListener("mouseenter", () => showPopover(badge, info));
+			badge.addEventListener("mouseleave", hidePopoverSoon);
+			badge.addEventListener("click", (event) => {
+				// A drag-select over the badge must not fire a jump.
+				const selection = doc.getSelection === undefined ? null : doc.getSelection();
+				if (selection !== null && selection.isCollapsed === false) return;
+				jumpToSource(segment.quote, sessionId);
+			});
+			return badge;
+		}
+
+		/** Split one text node into plain text and badges, once. */
+		function enhanceRefNode(node) {
+			if (refBadges.has(node)) return;
+			if (isRefCandidate(node) !== true) return;
+			const value = node.nodeValue;
+			const parts = value.split(/(\u300c\u5f15\u7528\d+\u300d)/u);
+			if (parts.length < 3) return;
+			const parent = node.parentNode;
+			const doc = node.ownerDocument === null || node.ownerDocument === undefined ? (parent === null ? null : parent.ownerDocument) : node.ownerDocument;
+			if (parent === null || doc === null || doc === undefined) return;
+			const host = parent.closest !== undefined ? parent.closest(CONTENT_SELECTOR) : null;
+			if (host === null) return;
+			const sessionId = (() => {
+				const id = host.getAttribute("data-conversation-session");
+				return typeof id === "string" ? id : null;
+			})();
+			const quotes = precedingQuoteSegments(node, host);
+			if (quotes.length === 0) return;
+
+			const nodes = [];
+			// The original node keeps the first chunk; everything else is inserted
+			// after it, in order, so React's node stays where reconciliation left it.
+			node.nodeValue = parts[0];
+			let previous = node;
+			for (let index = 1; index < parts.length; index += 1) {
+				const part = parts[index];
+				let created = null;
+				if (index % 2 === 1) {
+					const number = Number(part.slice(3, -1));
+					const segment = number >= 1 && number <= quotes.length ? quotes[number - 1] : null;
+					created = segment === null ? doc.createTextNode(part) : refBadgeFor(doc, sessionId, part, segment);
+				} else {
+					created = doc.createTextNode(part);
+				}
+				if (created === null) continue;
+				parent.insertBefore(created, previous.nextSibling);
+				previous = created;
+				nodes.push(created);
+			}
+			refBadges.set(node, { text: value, head: parts[0], nodes });
+		}
+
+		/** Reconcile the ledger, then split whatever is still pending. */
+		function flushRefBadges() {
+			for (const [node, known] of Array.from(refBadges)) {
+				if (node.isConnected === false) {
+					removeRefNodes(known);
+					refBadges.delete(node);
+					continue;
+				}
+				// React rewrote the text: our chunks duplicate the tail now. Drop
+				// everything we added and re-read the node's fresh value.
+				if (node.nodeValue !== known.head) {
+					removeRefNodes(known);
+					refBadges.delete(node);
+					refDirty.add(node);
+				}
+			}
+			if (refDirty.size === 0) return;
+			const candidates = Array.from(refDirty);
+			refDirty.clear();
+			for (const node of candidates) {
+				if (node.isConnected === true) enhanceRefNode(node);
+			}
+		}
+
+		function uninstallRefBadges() {
+			for (const [node, known] of Array.from(refBadges)) {
+				removeRefNodes(known);
+				// Restoring is only honest while React never touched the value
+				// after the split; otherwise the fresh value is the truth.
+				if (node.isConnected && node.nodeValue === known.head) {
+					try {
+						node.nodeValue = known.text;
+					} catch (error) {
+						// A read-only node only costs its original wording.
+					}
+				}
+			}
+			refBadges.clear();
+			refDirty.clear();
+		}
+
 		/* ------------------------------------------------------------------ *
 		 * Bar element
 		 * ------------------------------------------------------------------ */
@@ -1683,11 +2028,15 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				mode: null,
 				sessionId: null,
 				comment: "",
-				/** True when the selection came from the preview or the terminal:
-				 *  the quote travels as a fenced code block, not a plain quote. */
-				code: false,
-				/** Where the current selection was picked up, for the jump-back row. */
-				source: null,
+			/** True when the selection came from the preview or the terminal:
+			 *  the quote travels as a fenced code block, not a plain quote. */
+			code: false,
+			/** The file a preview selection came from, when the host exposes it. */
+			path: null,
+			/** 逐条回应: the current quote asks the model to answer per quote. */
+			reply: false,
+			/** Where the current selection was picked up, for the jump-back row. */
+			source: null,
 			/** The quote key being corrected, when the box was opened by 改这条引用. */
 			revising: null,
 			settle: null,
@@ -1871,6 +2220,20 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			quoteInput.addEventListener("keydown", onKey);
 			input.addEventListener("keydown", onKey);
 
+			// 逐条回应: one opt-in checkbox. On, the block carries a transport
+			// instruction asking the model to answer per quote, and the reply's
+			// `「引用N」` labels become badges that link back to these quotes.
+			// Off (the default), the wire stays exactly the shape it always was.
+			const replyCheck = el(doc, "input", { type: "checkbox", class: "dshq-reply-check" });
+			replyCheck.checked = state.reply === true;
+			replyCheck.addEventListener("change", () => {
+				state.reply = replyCheck.checked === true;
+			});
+			const replyToggle = el(doc, "label", { class: "dshq-reply" }, [
+				replyCheck,
+				el(doc, "span", { text: translate("replyToggle") })
+			]);
+
 			grow(quoteInput);
 			syncConfirm();
 
@@ -1878,6 +2241,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				el(doc, "div", { class: "dshq-comment" }, [
 					quoteInput,
 					input,
+					replyToggle,
 					el(doc, "div", { class: "dshq-actions" }, [
 						el(doc, "button", { type: "button", class: "dshq-btn", "data-action": "cancel" }, [translate("cancel")]),
 						confirm
@@ -1921,6 +2285,8 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			state.sessionId = found.sessionId;
 			state.comment = "";
 			state.code = found.hostKind === "preview" || found.hostKind === "terminal";
+			state.path = typeof found.path === "string" ? found.path : null;
+			state.reply = false;
 			state.source = found.source === undefined ? null : found.source;
 			state.mode = "menu";
 			state.suppress = false;
@@ -1952,6 +2318,8 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			state.quote = quote;
 			state.comment = typeof comment === "string" ? comment : "";
 			state.code = code === true;
+			state.path = null;
+			state.reply = false;
 			state.sessionId = sessionId === null || sessionId === undefined ? null : sessionId;
 			state.source = sourceFor(quote);
 			state.revising = sourceKeyOf(quote);
@@ -1977,6 +2345,8 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			state.sessionId = null;
 			state.comment = "";
 			state.code = false;
+			state.path = null;
+			state.reply = false;
 			state.source = null;
 			state.revising = null;
 			state.suppress = true;
@@ -2014,6 +2384,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			const source = state.source;
 			const revising = state.revising;
 			const code = state.code;
+			const meta = { path: state.path, reply: state.reply === true };
 			const entry = sessionId === null ? null : sessions.get(sessionId);
 			const trimmed = typeof comment === "string" ? comment.trim() : "";
 			close();
@@ -2034,11 +2405,11 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			// the fallback for every build where that service face is missing.
 			// A comment rides inside that chip — one node, one capsule after the
 			// send — so 评论 writes nothing else into the draft.
-			if (insertChip(entry, sessionId, text, trimmed, code)) {
+			if (insertChip(entry, sessionId, text, trimmed, code, meta)) {
 				focusComposer();
 				return;
 			}
-			if (insertPayload(entry, buildPayload(text, trimmed, code))) focusComposer();
+			if (insertPayload(entry, buildPayload(text, trimmed, code, meta))) focusComposer();
 			else toast(translate("failed"));
 		}
 
@@ -2093,13 +2464,15 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		 * `❝` marks stay out on purpose — they exist for the MAIN transcript's
 		 * capsule enhancer, and the side thread renders its own way. A code quote
 		 * keeps its fence instead: that composer talks to the model, and a fenced
-		 * block is what the model reads as code.
+		 * block is what the model reads as code. A preview quote puts its file
+		 * into the fence's info string, the same slot the main wire uses.
 		 */
-		function sideQuestion(text, code) {
+		function sideQuestion(text, code, path) {
 			const lines = blockLines(text);
 			if (code === true && lines.length > 0) {
 				const fence = lines.some((line) => /^\s*```/u.test(line)) ? "~~~" : "```";
-				return [fence].concat(lines, [fence]).join("\n");
+				const clean = sanitizePath(path) ?? "";
+				return [fence + (clean === "" ? "" : " " + clean)].concat(lines, [fence]).join("\n");
 			}
 			return lines
 				.map((line) => (line.trim() === "" ? ">" : "> " + line))
@@ -2301,9 +2674,10 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 		 * @param {string} sessionId - the session the quote came from.
 		 * @param {string} text - the quoted text.
 		 * @param {boolean} [code] - true when the quote is code (preview/terminal).
+		 * @param {string | null} [path] - the file a preview quote came from.
 		 * @returns {Promise<void>} resolves once the draft is written or refused.
 		 */
-		function sideChatRequest(service, sessionId, text, code) {
+		function sideChatRequest(service, sessionId, text, code, path) {
 			if (typeof sessionId !== "string" || sessionId === "" || typeof text !== "string" || text.trim() === "") {
 				return Promise.resolve();
 			}
@@ -2335,7 +2709,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				rememberSideThread(sessionId, childId);
 				const threadId = await displayedThreadId(sessionId, childId);
 				rememberSideThread(sessionId, threadId);
-				if (!(await prefillDraft(threadId, sideQuestion(text, code === true)))) {
+				if (!(await prefillDraft(threadId, sideQuestion(text, code === true, path)))) {
 					console.warn("[ui-quote] sidechat draft not written:", threadId);
 					toast(translateFor(sessionId, "sideChatDraftFailed"));
 				}
@@ -2360,6 +2734,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 			if (sessionId === null || text === null) return;
 			const service = sideChatService();
 			const code = state.code;
+			const path = state.path;
 			close();
 			// Kimi drops the transcript selection the moment an action is chosen.
 			const selection = document.getSelection === undefined ? null : document.getSelection();
@@ -2368,7 +2743,7 @@ code's own spacing — collapsed keeps one clipped line, expanded scrolls. */
 				toast(translateFor(sessionId, "sideChatFailed"));
 				return;
 			}
-			sideChatRequest(service, sessionId, text, code);
+			sideChatRequest(service, sessionId, text, code, path);
 		}
 
 		/* ------------------------------------------------------------------ *
@@ -2624,7 +2999,10 @@ border-top:1px solid color-mix(in srgb,currentColor 18%,transparent)}
 						time: typeof event.time === "string" ? event.time : "",
 						quote: segment.quote,
 						comment: typeof segment.comment === "string" ? segment.comment : "",
-						code: segment.code !== null && segment.code !== undefined
+						code: segment.code !== null && segment.code !== undefined,
+						// The fence's info string (a preview quote carries its file
+						// there) — the export puts it back on its own fence line.
+						fence: typeof segment.code === "string" ? segment.code : ""
 					});
 				}
 			}
@@ -2651,9 +3029,11 @@ border-top:1px solid color-mix(in srgb,currentColor 18%,transparent)}
 			}
 			list.forEach((row, index) => {
 				lines.push("## " + (index + 1) + ". " + firstLineOf(row.quote, 80), "");
-				// A code quote exports as a real fenced block, not a blockquote.
+				// A code quote exports as a real fenced block, not a blockquote; a
+				// preview quote's file rides in the info string, as it did on the wire.
 				if (row.code === true) {
-					lines.push("```", String(row.quote), "```", "");
+					const info = typeof row.fence === "string" && row.fence !== "" ? " " + row.fence : "";
+					lines.push("```" + info, String(row.quote), "```", "");
 				} else {
 					for (const line of String(row.quote).split("\n")) lines.push("> " + line);
 					lines.push("");
@@ -3384,6 +3764,9 @@ border-top:1px solid color-mix(in srgb,currentColor 18%,transparent)}
 			splitQuoteRuns,
 			chipRef,
 			chipLabel,
+			sanitizePath,
+			previewPathOf,
+			withLineRange,
 			rememberChip,
 			normalizeLabel,
 			barTop,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-client-ui-quote",
-  "version": "0.10.0",
-  "description": "Select text in the DSH transcript, a file preview or the terminal to quote it into the composer or into a side thread's composer, Kimi-Code style (comment / add to conversation / side chat), with Alt+Q/C/B, a jump back to the quoted source, a searchable quote list page that exports as Markdown, one-click back-flow of a side thread's conclusion, and revisions of a sent quote that mark the old capsule as superseded. The quoted text itself is editable in the comment box (trim a selection, correct a revision's wording), and a selection from the file preview or the terminal travels to the model as a fenced code block.",
+  "version": "0.11.1",
+  "description": "Select text in the DSH transcript, a file preview or the terminal to quote it into the composer or into a side thread's composer, Kimi-Code style (comment / add to conversation / side chat), with Alt+Q/C/B, a jump back to the quoted source, a searchable quote list page that exports as Markdown, one-click back-flow of a side thread's conclusion, and revisions of a sent quote that mark the old capsule as superseded. The quoted text itself is editable in the comment box (trim a selection, correct a revision's wording), a selection from the file preview or the terminal travels to the model as a fenced code block carrying its file path and line range, and a per-quote reply toggle has the model answer quote by quote, each 「引用N」 label in the reply becoming a badge linked back to the quote.",
   "icon": "icon.svg",
   "license": "MIT",
   "author": "BangBang-03",

package/test/capsule.mjs

@@ -1047,6 +1047,304 @@ try {
 	codeCap.dispatch("mouseleave", {});
 }
 
+/* ------------------------------------------------------------------ *
+ * 文件路径 + 逐条回应 — the wire's two new transport-only forms
+ * ------------------------------------------------------------------ */
+
+{
+	// 预览引用: the file rides in the fence's info string, where Markdown keeps
+	// metadata the model reads but renderers never show as content.
+	check(
+		"a preview quote puts its file into the fence info string",
+		testing.quoteBlock("const x = 1;", "", true, { path: "src/app.ts" }) === "> ❝ ``` src/app.ts\n> const x = 1;\n> ```",
+		JSON.stringify(testing.quoteBlock("const x = 1;", "", true, { path: "src/app.ts" }))
+	);
+	const pathSegments = testing.splitQuoteRuns(testing.quoteBlock("const x = 1;", "看一下", true, { path: "src/app.ts" }));
+	check(
+		"the path parses back as the fence's info string",
+		pathSegments?.length === 1 && pathSegments[0].code === "src/app.ts" && pathSegments[0].quote === "const x = 1;" && pathSegments[0].comment === "看一下",
+		JSON.stringify(pathSegments)
+	);
+	check(
+		"a path rides along when the content forces ~~~",
+		testing.quoteBlock("```\nx = 1\n```", "", true, { path: "src/a.ts" }) === "> ❝ ~~~ src/a.ts\n> ```\n> x = 1\n> ```\n> ~~~",
+		JSON.stringify(testing.quoteBlock("```\nx = 1\n```", "", true, { path: "src/a.ts" }))
+	);
+	check(
+		"a path with whitespace is dropped, not smuggled",
+		testing.quoteBlock("x", "", true, { path: "my file.ts" }) === "> ❝ ```\n> x\n> ```",
+		JSON.stringify(testing.quoteBlock("x", "", true, { path: "my file.ts" }))
+	);
+	check(
+		"sanitizePath takes the obvious rejects",
+		testing.sanitizePath(" src/a.ts ") === "src/a.ts" &&
+			testing.sanitizePath("a b") === null &&
+			testing.sanitizePath("a`b") === null &&
+			testing.sanitizePath("a~b") === null &&
+			testing.sanitizePath("") === null,
+		JSON.stringify([testing.sanitizePath(" src/a.ts "), testing.sanitizePath("a b"), testing.sanitizePath("a`b"), testing.sanitizePath("a~b"), testing.sanitizePath("")])
+	);
+
+	// 逐条回应: one instruction line at the block's tail, wire-only.
+	const replyWire = testing.quoteBlock("正文", "看看这里", false, { reply: true });
+	check(
+		"逐条回应 appends one instruction line to the block",
+		replyWire === "> ❝ 正文\n> ❞ 看看这里\n> ※ 指令：请把本条消息里的引用块按出现顺序记为「引用1」「引用2」…，回复时逐条对应回应，每条回应前标注「引用N」。",
+		JSON.stringify(replyWire)
+	);
+	const replySegments = testing.splitQuoteRuns(replyWire);
+	check(
+		"the instruction never reaches the capsule",
+		replySegments?.length === 1 && replySegments[0].comment === "看看这里" && JSON.stringify(replySegments).includes("指令") === false,
+		JSON.stringify(replySegments)
+	);
+	const replyBare = testing.splitQuoteRuns(testing.quoteBlock("正文", "", false, { reply: true }));
+	check(
+		"a reply instruction without a comment leaves the comment half empty",
+		replyBare?.length === 1 && replyBare[0].comment === "" && replyBare[0].quote === "正文",
+		JSON.stringify(replyBare)
+	);
+	const replyCode = testing.splitQuoteRuns(testing.quoteBlock("x=1", "改这里", true, { path: "src/a.ts", reply: true }));
+	check(
+		"path and instruction travel in one code block",
+		replyCode?.length === 1 && replyCode[0].code === "src/a.ts" && replyCode[0].comment === "改这里" && JSON.stringify(replyCode).includes("指令") === false,
+		JSON.stringify(replyCode)
+	);
+	check(
+		"the side thread's fence carries the file too",
+		testing.sideQuestion("x=1", true, "src/app.ts") === "``` src/app.ts\nx=1\n```",
+		JSON.stringify(testing.sideQuestion("x=1", true, "src/app.ts"))
+	);
+	check(
+		"the side thread drops a whitespace path",
+		testing.sideQuestion("x=1", true, "my file.ts") === "```\nx=1\n```",
+		JSON.stringify(testing.sideQuestion("x=1", true, "my file.ts"))
+	);
+
+	// previewPathOf: walk the ancestors, skip values that cannot be a path.
+	const outer = dom.document.createElement("div");
+	outer.setAttribute("data-file-path", "src/app.ts");
+	const mid = dom.document.createElement("div");
+	mid.setAttribute("data-textpreview-body", "");
+	mid.setAttribute("data-path", "bad path");
+	outer.append(mid);
+	check(
+		"previewPathOf finds the ancestor's path and skips a whitespace one",
+		testing.previewPathOf(mid) === "src/app.ts",
+		JSON.stringify(testing.previewPathOf(mid))
+	);
+	check("previewPathOf misses cleanly on a bare host", testing.previewPathOf(dom.document.createElement("div")) === null);
+
+	// The real host shape: the path label lives in a header SIBLING of the body
+	// the selection is in — the probe has to find it through the preview root,
+	// reading the full path from the label's title.
+	const previewRoot = dom.document.createElement("div");
+	previewRoot.setAttribute("data-document-preview", "doc-1");
+	const header = dom.document.createElement("div");
+	const label = dom.document.createElement("span");
+	label.setAttribute("data-textpreview-path", "");
+	label.setAttribute("title", "src/app.ts");
+	header.append(label);
+	const previewBody = dom.document.createElement("div");
+	previewBody.setAttribute("data-textpreview-body", "");
+	previewRoot.append(header);
+	previewRoot.append(previewBody);
+	check(
+		"previewPathOf reads the header's path label through the preview root",
+		testing.previewPathOf(previewBody) === "src/app.ts",
+		JSON.stringify(testing.previewPathOf(previewBody))
+	);
+	const clippedLabel = dom.document.createElement("span");
+	clippedLabel.setAttribute("data-textpreview-path", "");
+	clippedLabel.setAttribute("title", "my file.ts");
+	const clippedRoot = dom.document.createElement("div");
+	clippedRoot.setAttribute("data-document-preview", "doc-2");
+	clippedRoot.append(clippedLabel, dom.document.createElement("div"));
+	check(
+		"a label whose path cannot be a token costs nothing",
+		testing.previewPathOf(clippedRoot.lastChild) === null,
+		JSON.stringify(testing.previewPathOf(clippedRoot.lastChild))
+	);
+
+	// withLineRange: GitHub's #L spelling, normalized, or nothing.
+	check(
+		"withLineRange composes the GitHub line range",
+		testing.withLineRange("src/app.ts", 12, 48) === "src/app.ts#L12-L48" &&
+			testing.withLineRange("src/app.ts", 7, 7) === "src/app.ts#L7" &&
+			testing.withLineRange("src/app.ts", 48, 12) === "src/app.ts#L12-L48",
+		JSON.stringify([testing.withLineRange("src/app.ts", 12, 48), testing.withLineRange("src/app.ts", 7, 7), testing.withLineRange("src/app.ts", 48, 12)])
+	);
+	check(
+		"withLineRange degrades honestly",
+		testing.withLineRange("my file.ts", 1, 2) === null && testing.withLineRange("src/a.ts", null, 4) === "src/a.ts" && testing.withLineRange("src/a.ts", 0, 4) === "src/a.ts",
+		JSON.stringify([testing.withLineRange("my file.ts", 1, 2), testing.withLineRange("src/a.ts", null, 4), testing.withLineRange("src/a.ts", 0, 4)])
+	);
+	check(
+		"a path with a range still parses back as the fence info string",
+		testing.splitQuoteRuns(testing.quoteBlock("const x = 1;", "", true, { path: "src/app.ts#L12-L48" }))?.[0]?.code === "src/app.ts#L12-L48",
+		JSON.stringify(testing.splitQuoteRuns(testing.quoteBlock("const x = 1;", "", true, { path: "src/app.ts#L12-L48" }))
+		)
+	);
+}
+
+/* ------------------------------------------------------------------ *
+ * 回复徽章 — the model's 「引用N」 labels link back to the quotes
+ * ------------------------------------------------------------------ */
+
+{
+	const badgeHost = dom.document.createElement("div");
+	badgeHost.setAttribute("data-conversation-content", "");
+	badgeHost.setAttribute("data-conversation-session", "session-badge");
+	const userBubble = dom.document.createElement("div");
+	const quoteRun = dom.document.createElement("span");
+	quoteRun.className = "plainRun";
+	const replyValue = "回答一「引用1」；回答二「引用2」；越界「引用9」；结尾";
+	quoteRun.textContent = "问题" + testing.quoteBlock("第一处引用", "注一") + "\n\n中间的话\n\n" + testing.quoteBlock("第二处引用", "注二") + "\n\n";
+	userBubble.append(quoteRun);
+	badgeHost.append(userBubble);
+	const replyParagraph = dom.document.createElement("p");
+	const replyText = dom.document.createTextNode(replyValue);
+	replyParagraph.append(replyText);
+	badgeHost.append(replyParagraph);
+	dom.document.body.append(badgeHost);
+	dom.document.deliver();
+	await wait(120);
+
+	const badges = () => replyParagraph.querySelectorAll(".dshq-ref");
+	check("two quoted messages come back as two capsules", badgeHost.querySelectorAll(".dshq-cap").length === 2, badgeHost.querySelectorAll(".dshq-cap").length + " capsule(s)");
+	check("a reply label becomes a badge", badges().length === 2, badges().length + " badge(s)");
+	check(
+		"the reply reads the same with badges in place",
+		replyParagraph.textContent === replyValue,
+		JSON.stringify(replyParagraph.textContent)
+	);
+	check(
+		"only labels the quotes can answer are badged",
+		JSON.stringify(Array.from(badges()).map((badge) => badge.textContent)) === JSON.stringify(["「引用1」", "「引用2」"]),
+		JSON.stringify(Array.from(badges()).map((badge) => badge.textContent))
+	);
+
+	// An assistant reply in a conversation with no quoted message stays plain.
+	const bareHost = dom.document.createElement("div");
+	bareHost.setAttribute("data-conversation-content", "");
+	bareHost.setAttribute("data-conversation-session", "session-bare");
+	const bareParagraph = dom.document.createElement("p");
+	bareParagraph.textContent = "回应「引用1」但没有先前的引用";
+	bareHost.append(bareParagraph);
+	dom.document.body.append(bareHost);
+	dom.document.deliver();
+	await wait(120);
+	check("a reply without a preceding quote is not badged", bareParagraph.querySelectorAll(".dshq-ref").length === 0, bareParagraph.querySelectorAll(".dshq-ref").length + " badge(s)");
+
+	// The badge reuses the hover card, quote and comment in full.
+	const firstBadge = badges()[0];
+	firstBadge.rect = { left: 80, top: 300, width: 64, height: 20 };
+	firstBadge.dispatch("mouseenter", {});
+	check(
+		"hovering a badge opens the quote's card",
+		pop()?.querySelector(".dshq-pop-quote")?.textContent === "第一处引用",
+		JSON.stringify(pop()?.querySelector(".dshq-pop-quote")?.textContent)
+	);
+	check(
+		"the badge's card shows the comment too",
+		pop()?.querySelector(".dshq-pop-comment")?.textContent === "注一",
+		JSON.stringify(pop()?.querySelector(".dshq-pop-comment")?.textContent)
+	);
+	firstBadge.dispatch("mouseleave", {});
+	await wait(200);
+	check("leaving a badge closes the card", pop()?.dataset.visible === "false", JSON.stringify(pop()?.dataset.visible));
+
+	// A quote the plugin never watched has no coordinates: clicking the badge
+	// must not pretend to jump — no throw, no toast. (An earlier section left a
+	// jump-failure toast mid-display; hide it first so only this click counts.)
+	const leftoverToast = dom.document.getElementById("dsh-quote-toast");
+	if (leftoverToast !== null) leftoverToast.dataset.visible = "false";
+	check("the badge's quote was never traced", testing.sourceFor("第一处引用") === null);
+	firstBadge.dispatch("click", { stopPropagation() {} });
+	check(
+		"a badge without coordinates jumps nowhere quietly",
+		dom.document.getElementById("dsh-quote-toast")?.dataset.visible !== "true",
+		JSON.stringify(dom.document.getElementById("dsh-quote-toast")?.dataset.visible)
+	);
+
+	dom.document.deliver();
+	await wait(120);
+	check("an unrelated flush does not duplicate badges", badges().length === 2, badges().length + " badge(s)");
+
+	// React rewrites the text node: the stale split goes and the fresh value
+	// is re-read, so the badges always match what the reply says now.
+	replyText.textContent = "改写后只提「引用2」一次";
+	dom.document.deliver();
+	await wait(120);
+	check(
+		"a rewritten reply re-badges from the fresh text",
+		badges().length === 1 && badges()[0].textContent === "「引用2」" && replyParagraph.textContent === "改写后只提「引用2」一次",
+		JSON.stringify([badges().length, replyParagraph.textContent])
+	);
+
+	// Uninstall puts the original text back and takes every badge with it.
+	capsuleEffect.dispose();
+	check(
+		"uninstall restores the reply text and drops the badges",
+		replyParagraph.querySelectorAll(".dshq-ref").length === 0 && replyParagraph.textContent === "改写后只提「引用2」一次",
+		JSON.stringify(replyParagraph.textContent)
+	);
+}
+
+/* ------------------------------------------------------------------ *
+ * 逐条回应的开关 — the comment box checkbox drives the wire
+ * ------------------------------------------------------------------ */
+
+{
+	const overlay = registered.find((entry) => entry.spec.name === "conversation.input.overlay");
+	const toggleInsertions = [];
+	shells.set("session-toggle", {
+		insertReference(attachment) {
+			toggleInsertions.push(attachment);
+			return true;
+		}
+	});
+	if (overlay !== undefined) overlay.Component({ sessionId: "session-toggle", inputActions: { captureInsertion: () => ({ draftRev: 1 }) } });
+
+	testing.startRevision("一处引用", "", "session-toggle", null, false);
+	const bar = dom.document.getElementById("dsh-quote-bar");
+	const replyCheck = bar?.querySelector(".dshq-reply-check");
+	check("the comment box carries the per-quote toggle", replyCheck !== null && replyCheck !== undefined);
+	check("the toggle starts off", replyCheck?.checked === false, String(replyCheck?.checked));
+	const quoteBox = bar.querySelector(".dshq-quote-input");
+	const commentBox = bar.querySelector(".dshq-comment-input");
+	const confirmBtn = bar.querySelector('[data-action="confirm"]');
+	quoteBox.value = "一处引用";
+	quoteBox.dispatch("input", {});
+	commentBox.value = "请照着改";
+	commentBox.dispatch("input", {});
+	bar.dispatch("click", { target: confirmBtn });
+	check(
+		"toggle off: the wire carries no instruction",
+		toggleInsertions.length === 1 && String(toggleInsertions[0]?.ref ?? "").includes("指令") === false,
+		JSON.stringify(String(toggleInsertions[0]?.ref ?? "").trim())
+	);
+
+	testing.startRevision("一处引用", "", "session-toggle", null, false);
+	const bar2 = dom.document.getElementById("dsh-quote-bar");
+	const replyCheck2 = bar2.querySelector(".dshq-reply-check");
+	replyCheck2.checked = true;
+	replyCheck2.dispatch("change", {});
+	const quoteBox2 = bar2.querySelector(".dshq-quote-input");
+	const commentBox2 = bar2.querySelector(".dshq-comment-input");
+	const confirmBtn2 = bar2.querySelector('[data-action="confirm"]');
+	quoteBox2.value = "一处引用";
+	quoteBox2.dispatch("input", {});
+	commentBox2.value = "请照着改";
+	commentBox2.dispatch("input", {});
+	bar2.dispatch("click", { target: confirmBtn2 });
+	check(
+		"toggle on: the wire carries the per-quote instruction",
+		toggleInsertions.length === 2 && String(toggleInsertions[1]?.ref ?? "").includes("※ 指令："),
+		JSON.stringify(String(toggleInsertions[1]?.ref ?? "").trim().slice(-40))
+	);
+}
+
 console.log(
 	failures.length === 0
 		? "\ndsh-client-ui-quote capsule: " + passed + " checks passed"

package/test/dom.mjs

@@ -35,6 +35,12 @@ class ShimNode {
 		return this.childNodes.length === 0 ? null : this.childNodes[this.childNodes.length - 1];
 	}
 
+	get nextSibling() {
+		if (this.parentNode === null) return null;
+		const siblings = this.parentNode.childNodes;
+		return siblings[siblings.indexOf(this) + 1] ?? null;
+	}
+
 	append(child) {
 		this.insertBefore(child, null);
 	}

package/test/panel.mjs

@@ -240,6 +240,28 @@ check(
 	testing.quoteRowsFromEntries(entries).every((row) => row.code === false),
 	JSON.stringify(testing.quoteRowsFromEntries(entries).map((row) => row.code))
 );
+const pathEntries = [
+	{
+		type: "event",
+		event: {
+			type: "user/message",
+			seq: 5,
+			time: "",
+			data: { id: "e6", content: [{ type: "text", text: "> ❝ ``` src/app.ts\n> const x = 1;\n> ```\n> ❞ 看一下" }] }
+		}
+	}
+];
+const pathRows = testing.quoteRowsFromEntries(pathEntries);
+check(
+	"a preview quote's file rides in the row",
+	pathRows.length === 1 && pathRows[0].code === true && pathRows[0].fence === "src/app.ts" && pathRows[0].comment === "看一下",
+	JSON.stringify(pathRows[0])
+);
+check(
+	"the export puts the file on its fence line",
+	testing.quoteListMarkdown(pathRows, "引用清单").includes("``` src/app.ts\nconst x = 1;\n```"),
+	JSON.stringify(testing.quoteListMarkdown(pathRows, "引用清单"))
+);
 
 // ---- reading a session that is not on screen -------------------------------
 sessionFixture = {