dsh-quote-shot 0.1.1 → 0.2.0

package/README.md

@@ -55,6 +55,46 @@ node install.mjs          # 链接进 profile 并写入 dsh.profile.bundles
 
 ---
 
+## 输入框里是一枚 chip，不是一行指令
+
+点引用按钮后，输入框里出现的是紧凑标签，而不是原来那行长文本：
+
+```
+〔 引用 · 好，我测试一下，我看了这次改动… 〕
+```
+
+**这是纯外观改动。** chip 的 `label` 显示被引用内容的开头，但底层 `clipboardText` 和序列化结果仍是原来那行标记，所以：
+
+- 模型收到的内容不变
+- `quote_read` 行为不变
+- context 成本不变（仍然只传 id）
+
+chip 用 DSH 原生的 `inputTriggers.registerSource` 注册。**DSH 的输入框无法装饰纯文本**——要让一段内容显示成标签，只能让它成为编辑器认识的「引用」对象，这是唯一的路。
+
+草稿 API 不可用时会自动退回纯文本插入，引用照常能用。
+
+## 发送后：标记渲染成卡片
+
+发送之后，那行 `[引用消息 <id>——…]` 会在气泡里变成一张卡片：
+
+```
+┌ “ 引用 1a2b3c4d                    展开
+└ （点「展开」后显示被引用消息的正文，最高 220px 可滚动）
+```
+
+- 卡片总是排在你自己说的话**之前**：标记插入后会被移到草稿顶端
+- **点卡片主体 = 瞬间跳回原消息**，并在那一块下方画一条梭形横线（两端淡出，约 1.6 秒后消失）
+- **点「展开」= 取正文**（`POST /quote-shot/message`），不预取——否则一屏十几条引用就是十几个请求
+- 取正文和 `quote_read` 工具共用同一套三级查找（`resolveMessageText`），不会出现两边行为不一致
+
+**跳转靠点击引用时记下的 DOM 锚点**（`data-chat-anchor-key`，存在 localStorage，最多 200 条）——DSH 的消息 DOM 上没有 message id，只有这个锚点。跳转是**瞬间定位**（不是平滑滚动）：跳几千上万像素时，滚动动画耗时比测量窗口还长，测到的会是滚动前的坐标。
+
+**滚出加载区的消息不在 DOM 里**（列表虚拟化），这时卡片提示「原消息不在当前视图」，不会假装滚动。刷新页面后锚点仍在，仍可跳转。
+
+**标记是一条梭形横线，不是一个框**：外层描边会把「引用按钮所在的那一块」框住——那通常是这一轮的文件变更卡片，而不是消息本身。横线只回答「是这一带」，且用固定定位浮层绘制，不往宿主节点上写任何 class 或 style。
+
+**这只是「人眼看到什么」的改变**：模型收到的仍然是那行标记，仍然需要调用 `quote_read` 才能读到正文。卡片不省 token，也不改变模型行为。
+
 ## 实现
 
 ### 链路
@@ -128,7 +168,7 @@ ctx.tools.register({
 })
 ```
 
-### 引用功能本身的七个坑
+### 引用功能本身的九个坑
 
 | # | 坑 | 后果 | 教训 |
 |---|---|---|---|
@@ -139,6 +179,8 @@ ctx.tools.register({
 | 5 | 「第一个够长就返回」 | 抓到路径碎片（87 字） | 取**最外层**候选，不是最近的 |
 | 6 | 用 `useInput` 的 `phase` 判断发送 | 那个字段不存在 | **未验证的 API 假设 = 建在沙子上** |
 | 7 | **`innerText ?? textContent`** | **0.2.2 后引用全空** | 见下，这是最隐蔽的一个 |
+| 8 | 拿「最后一个 live agent」当调用者 | 后台 subagent 一活跃就 `not-found` | **live agent ≠ 调用者**；后台 reviewer 也是活 agent |
+| 9 | 只认 `session-<uuid>` 会话目录 | 大部分会话读不到 | DSH 两种目录命名并存，裸 uuid 也要试 |
 
 ### ⚠️ 坑 7 展开：`innerText` 对未渲染元素返回 `""`，不是 `null`
 
@@ -220,11 +262,19 @@ quote_read(messageId) → { found, messageId, text }
 - 会话日志是**多帧 zstd**（每次追加一帧），普通解压只出第一帧，必须扫 magic `28 B5 2F FD` 逐帧解开
 - 消息 id 位置：`user/message → data.id`，`assistant/message → data.message.id`
 - 同一 id 可能跨多条事件（流式分片），文本要**累加**而非覆盖
-- 按文件 `mtimeMs` 缓存索引，会话增长时才重建
-- 工具拿不到 sessionId（`exec` 只带 `signal`），用 `ctx.agents.list()` 取**最近注册的活跃 agent** 反查
+- 按**文件路径**缓存索引（同一日志可能被两种目录名指向），文件增长时才重建
+- 会话目录有两种命名：`session-<uuid>` 与裸 `<uuid>`，**两种都要试**
+- 工具拿不到 sessionId（`exec` 只带 `signal`），所以按三级定位：① 客户端点击时上报的 `messageId → sessionId`；② 遍历**全部** live agent；③ 扫最近 25 个会话日志
 
 **已验证**：`quote_read('eb3fc73f-...')` 返回 113 字符原文，与日志里的 `len=113` 一致。
 
+**回归验证**：同一个 message id（`02dc5192-...`）在修复前返回 `not-found` 且日志无记录；修复后日志为
+
+```
+hint   message=02dc5192-... session=session-1db3d041-...
+quote_read session=session-1db3d041-... message=02dc5192-... len=894 via=hint
+```
+
 ## 开发
 
 ```sh
@@ -291,10 +341,10 @@ node install.mjs   # 安装 / 刷新
 | **裸标记触发** | ❌ **0 次**（设计缺陷） |
 | **显式指令标记触发** | ✅ 调用并读到 2318 字符 |
 
-**未验证的风险**（重要）：
+**风险与边界**：
 
 1. **模型可能不调**——这次是因为提问直接指向"引用的内容"，工具是唯一手段。如果引用只是背景（"按上面说的改一下"），模型可能凭印象作答而跳过工具。
-2. **多会话可能读错**——工具拿不到 sessionId，用 `ctx.agents.list()` 取**最近注册的活跃 agent** 反查。**多个对话同时活跃时可能读到错的那个**。
+2. **极冷的会话仍可能读不到**——三级定位覆盖「点击时上报的会话」「存活会话」「最近 25 个日志」。如果引用的是一条更早、更冷会话里的消息，扫盘窗口没覆盖到，仍会 `not-found`（此时日志会写明 `MISS` 和试过哪些会话）。
 
 ---
 
@@ -326,7 +376,7 @@ node install.mjs   # 安装 / 刷新
 
 - **草稿多一行标记**：`[引用消息 xxx]` 会出现在输入框里，发送后成为消息正文的一部分。
 - **模型可能不调工具**：见上，引用可能被忽略。
-- **多会话可能读错**：工具用「最近活跃 agent」反查会话，多对话并行时不保险。
+- **极冷的会话读不到**：定位覆盖点击时上报的会话、存活会话、最近 25 个日志；更早且未在窗口内的会话会 `not-found`。
 - **抓取的是「当时的 DOM」**：卡片预览是点击瞬间的快照。
 - **引用后不打字直接发送**：卡片不会自动收起（检测不到发送）。
 - **排版丢失**：DOM 提取只取 `innerText`，代码块/表格会变成纯文本。

package/client.js

@@ -15,6 +15,8 @@ window.__ModuleLoader__.load({
   factory: (require) => {
     var module = { exports: {} };
     var exports = module.exports;
+    /** Plugin context, for the components that need services outside a slot. */
+    let pluginCtx = null;
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
     const react = require('react');
@@ -42,6 +44,8 @@ window.__ModuleLoader__.load({
     const CARD_PREVIEW_CHARS = 60;
     /** Host route that performs the injection. */
     const INJECT_ROUTE = '/quote-shot/inject';
+    /** Host route where the click's session is reported for `quote_read`. */
+    const HINT_ROUTE = '/quote-shot/hint';
 
     //#region quote state
     /**
@@ -112,6 +116,31 @@ window.__ModuleLoader__.load({
         /* ignored on purpose */
       }
     }
+    /**
+     * Tell the Host which session this quote id belongs to.
+     *
+     * `quote_read` runs later with no session context, and the live-agent
+     * registry cannot be trusted to point at the caller (background subagents
+     * are live agents too). The click is the one moment the id and the session
+     * are both known, so it is recorded here.
+     *
+     * Fire-and-forget: a lost hint only costs the Host a slower fallback lookup.
+     *
+     * @param messageId - the quoted message id.
+     * @param sessionId - the session the button was clicked in.
+     */
+    function postHint(messageId, sessionId) {
+      try {
+        fetch(HINT_ROUTE, {
+          method: 'POST',
+          credentials: 'same-origin',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ messageId, sessionId })
+        }).catch(() => {});
+      } catch {
+        /* ignored on purpose */
+      }
+    }
     //#endregion
 
     /**
@@ -128,6 +157,281 @@ window.__ModuleLoader__.load({
      * @param anchor - the clicked button element.
      * @returns the text, or an empty string when nothing usable was found.
      */
+    /**
+     * Where a quoted message was on screen, keyed by message id.
+     *
+     * DSH's message DOM carries no message id — only `data-chat-anchor-key` — so
+     * a message id alone cannot find its row. The one moment the row IS known is
+     * the quote click, because the button lives inside it; the row's anchor is
+     * recorded then and replayed later.
+     *
+     * Global rather than per-session: ids are UUIDs so they cannot collide, and
+     * the sent-message card has no session id available.
+     */
+    const ANCHOR_STORE = 'dsh-quote-shot:anchors';
+    const ANCHOR_LIMIT = 200;
+
+    /**
+     * Chip source name.
+     *
+     * DSH renders a composer chip when the draft carries a reference of this
+     * source. The chip exists only for APPEARANCE: its label is a short tag, its
+     * clipboardText and serialised form are the same marker we have always sent,
+     * so the model and `quote_read` see exactly what they saw before.
+     */
+    const CHIP_SOURCE = 'quote-shot';
+
+    /**
+     * The marker that travels with the message.
+     *
+     * @param messageId - quoted message id.
+     * @returns the instruction line.
+     */
+    function buildMarker(messageId) {
+      return `[引用消息 ${messageId}——请先调用 quote_read 读取全文，再回答]`;
+    }
+
+    /**
+     * Insert one quote chip at the very top of the draft.
+     *
+     * Done as a single `setDraft` rather than insert-then-reorder: a chip has an
+     * offset, so moving text after the fact would desynchronise it.
+     *
+     * @param messageId - quoted message id.
+     * @param sessionId - the session owning the composer.
+     * @param preview - the quoted text, used for the chip's label.
+     * @returns true when the draft was rewritten.
+     */
+    function insertQuoteChip(messageId, sessionId, preview) {
+      const actx = pluginCtx?.sessions?.scope?.(sessionId);
+      const input = actx === undefined || actx === null ? undefined : pluginCtx?.conversation?.input?.for?.(actx);
+      const snapshot = input?.draftSnapshot;
+      if (snapshot === undefined || snapshot === null || typeof snapshot.text !== 'string') return false;
+
+      const marker = buildMarker(messageId);
+      const added = `${marker}\n`;
+      // An id alone tells the reader nothing; the opening words do.
+      const flat = String(preview ?? '').replace(/\s+/g, ' ').trim();
+      const label =
+        flat.length === 0
+          ? `引用 ${messageId.slice(0, 8)}`
+          : `引用 · ${flat.slice(0, 28)}${flat.length > 28 ? '…' : ''}`;
+      const chip = {
+        source: CHIP_SOURCE,
+        ref: messageId,
+        offset: 0,
+        length: marker.length,
+        label,
+        clipboardText: marker
+      };
+      const references = (Array.isArray(snapshot.references) ? snapshot.references : [])
+        .map((reference) => ({ ...reference, offset: reference.offset + added.length }));
+      references.push(chip);
+      references.sort((a, b) => a.offset - b.offset);
+
+      input.setDraft({ text: added + snapshot.text, references });
+      return true;
+    }
+
+    /**
+     * Remember which DOM row a message occupies.
+     *
+     * Stores the row anchor AND its turn id. The row is NOT a whole message: a
+     * reply is several rows (text, tool cards, file-change card) and the quote
+     * button lives in the LAST one, so highlighting just that row framed the
+     * file card instead of the answer. The turn id lets the jump widen to the
+     * whole exchange.
+     *
+     * @param messageId - quoted message id.
+     * @param row - the message row element.
+     */
+    function rememberAnchor(messageId, row) {
+      // Diagnose FIRST: the previous version returned before this ran whenever
+      // `closest` missed, which is exactly the case worth seeing. Records the
+      // whole ancestor chain (tag, class head, data-* attrs) so the real wrapper
+      // can be identified from outside.
+      try {
+        const chain = [];
+        let node = row;
+        for (let depth = 0; depth < 10 && node !== null && node !== undefined; depth += 1) {
+          const bits = [];
+          for (const attr of node.attributes ?? []) {
+            if (!attr.name.startsWith('data-')) continue;
+            bits.push(`${attr.name}=${String(attr.value).slice(0, 20)}`);
+            if (bits.length >= 3) break;
+          }
+          const cls = String(node.className ?? '').split(/\s+/).filter(Boolean)[0] ?? '';
+          chain.push(`${node.tagName?.toLowerCase()}.${cls.slice(0, 22)}[${bits.join(',')}]`);
+          node = node.parentElement;
+        }
+        postLog('anchor-chain', { rowFound: row !== null && row !== undefined, chain });
+      } catch {
+        /* diagnostics never break the click */
+      }
+
+      const key = row?.getAttribute?.('data-chat-anchor-key');
+      if (typeof key !== 'string' || key.length === 0) return;
+      const turn = row?.getAttribute?.('data-chat-turn') ?? null;
+      try {
+        const all = JSON.parse(localStorage.getItem(ANCHOR_STORE) ?? '{}');
+        delete all[messageId];
+        all[messageId] = { key, turn };
+        const ids = Object.keys(all);
+        for (const stale of ids.slice(0, Math.max(0, ids.length - ANCHOR_LIMIT))) delete all[stale];
+        localStorage.setItem(ANCHOR_STORE, JSON.stringify(all));
+      } catch {
+        /* storage is best-effort; jumping just degrades */
+      }
+    }
+
+    /**
+     * The recorded row anchor for a message.
+     *
+     * Tolerates the older plain-string format.
+     *
+     * @param messageId - quoted message id.
+     * @returns `{ key, turn }`, or null.
+     */
+    function anchorFor(messageId) {
+      try {
+        const all = JSON.parse(localStorage.getItem(ANCHOR_STORE) ?? '{}');
+        const value = all[messageId];
+        if (typeof value === 'string') return { key: value, turn: null };
+        if (value !== null && typeof value === 'object' && typeof value.key === 'string') return value;
+        return null;
+      } catch {
+        return null;
+      }
+    }
+
+    /**
+     * Scroll to a quoted message and flash it.
+     *
+     * Highlights the whole turn when the turn id is known, otherwise the row
+     * itself. Messages the virtualised list has not rendered are not in the DOM
+     * at all; there is no honest way to jump to them, so this reports "not on
+     * screen" instead of inventing a scroll.
+     *
+     * @param messageId - quoted message id.
+     * @returns true when something was found and scrolled to.
+     */
+    /** The flash line currently on screen, so a second jump replaces it. */
+    let flashLine = null;
+
+    /**
+     * Draw a spindle line under a row for a moment.
+     *
+     * A full outline around the row was wrong: it framed whichever block the
+     * quote button happens to live in (often a file-change card). A thin line
+     * marks the position without claiming a boundary, and it is drawn as a
+     * fixed-position overlay so no host node is touched.
+     *
+     * @param row - the row to underline.
+     */
+    function flashRow(row) {
+      if (flashLine !== null) {
+        flashLine.remove();
+        flashLine = null;
+      }
+
+      const paint = () => {
+        const rect = row.getBoundingClientRect();
+        postLog('flash-paint', {
+          top: Math.round(rect.top),
+          bottom: Math.round(rect.bottom),
+          width: Math.round(rect.width),
+          height: Math.round(rect.height),
+          viewport: window.innerHeight
+        });
+        if (rect.width === 0 || rect.height === 0) return;
+
+        // Keep the line inside the viewport: a tall row centred by scrollIntoView
+        // can have its bottom below the fold, and a line drawn there is invisible.
+        const maxY = window.innerHeight - 14;
+        const y = Math.max(12, Math.min(rect.bottom, maxY));
+        const line = document.createElement('div');
+        line.style.cssText = [
+          'position:fixed',
+          'pointer-events:none',
+          'z-index:2147483000',
+          `left:${rect.left + rect.width * 0.06}px`,
+          `width:${rect.width * 0.88}px`,
+          // Lifted off the row's bottom edge: sitting flush against it made the
+          // line read as the divider of the NEXT message.
+          `top:${y - 23}px`,
+          'height:3px',
+          'border-radius:2px',
+          'background:linear-gradient(90deg,transparent 0%,#4d6bfe 18%,#4d6bfe 82%,transparent 100%)',
+          'box-shadow:0 0 8px rgba(77,107,254,0.45)',
+          'opacity:0',
+          'transition:opacity 220ms ease'
+        ].join(';');
+        document.body.appendChild(line);
+        flashLine = line;
+        requestAnimationFrame(() => {
+          line.style.opacity = '1';
+        });
+        setTimeout(() => {
+          line.style.opacity = '0';
+        }, 1600);
+        setTimeout(() => {
+          line.remove();
+          if (flashLine === line) flashLine = null;
+        }, 2000);
+      };
+
+      // Wait until the row is actually INSIDE the viewport before measuring.
+      // Position stability alone is not enough: a scroll that has not started
+      // yet is perfectly stable, and measuring then draws the line off-screen.
+      let frames = 0;
+      const settle = () => {
+        frames += 1;
+        const rect = row.getBoundingClientRect();
+        const inView = rect.bottom > 8 && rect.top < window.innerHeight - 8;
+        if (inView && frames >= 2) {
+          paint();
+          return;
+        }
+        if (frames > 60) {
+          paint();
+          return;
+        }
+        requestAnimationFrame(settle);
+      };
+      requestAnimationFrame(settle);
+    }
+
+    function jumpToMessage(messageId) {
+      const record = anchorFor(messageId);
+      if (record === null) {
+        postLog('jump-miss', { messageId, reason: 'no-anchor' });
+        return false;
+      }
+
+      // Back to the behaviour that demonstrably worked: find the recorded row
+      // verbatim. The turn-prefix widening is gone until the row it lands on is
+      // understood; a broken jump is worse than an imprecise one.
+      let row = null;
+      try {
+        row = document.querySelector(`[data-chat-anchor-key="${CSS.escape(record.key)}"]`);
+      } catch (error) {
+        postLog('jump-miss', { messageId, reason: 'selector-error', detail: String((error && error.message) || error) });
+        return false;
+      }
+      if (row === null) {
+        postLog('jump-miss', { messageId, reason: 'row-gone', key: record.key });
+        return false;
+      }
+
+      // `behavior: 'auto'` on purpose. Smooth scrolling a jump of tens of
+      // thousands of pixels takes longer than the measuring window, and the line
+      // was then painted at a stale position (measured top: -19816).
+      row.scrollIntoView({ behavior: 'auto', block: 'center' });
+      flashRow(row);
+      postLog('jump-ok', { messageId, key: record.key });
+      return true;
+    }
+
     function readQuoteText(anchor) {
       try {
         const selection = window.getSelection();
@@ -404,6 +708,10 @@ window.__ModuleLoader__.load({
         }
 
         const text = readQuoteText(event.currentTarget);
+        // Record which row this message occupies: the message DOM carries no
+        // message id, and the sent card needs a way back. Done here because the
+        // button sits inside that row.
+        rememberAnchor(messageId, event.currentTarget.closest('[data-chat-anchor-key]'));
         if (text.length === 0) {
           // Ship the DOM shape along with the failure: message markup is not a
           // contract, so the extraction strategy cannot be fixed from a bare
@@ -427,20 +735,58 @@ window.__ModuleLoader__.load({
         // A bare `[引用消息 <id>]` failed in real use: the model decided it did
         // not need the content and answered from memory (measured 0 calls across
         // 3 quotes). Quoting means "look at this", so the marker now says so.
-        const marker = `[引用消息 ${messageId}——请先调用 quote_read 读取全文，再回答]`;
+        const marker = buildMarker(messageId);
         setBusy(true);
         let inserted = false;
+        let usedChip = false;
         try {
-          inserted = actions.insertText(`${marker}\n`, actions.captureInsertion());
-        } catch {
+          inserted = insertQuoteChip(messageId, sessionId, text);
+          usedChip = inserted;
+        } catch (error) {
+          postLog('chip-insert-failed', { messageId, detail: String((error && error.message) || error) });
           inserted = false;
         }
+        if (!inserted) {
+          // Fallback: plain text. The chip is nicer presentation, not a
+          // requirement — quoting must keep working even if the draft API
+          // behaves differently on another DSH build.
+          try {
+            inserted = actions.insertText(`${marker}\n`, actions.captureInsertion());
+          } catch {
+            inserted = false;
+          }
+        }
         setBusy(false);
         if (inserted !== true) {
           report('insert-failed', { messageId });
           return;
         }
 
+        // Only the plain-text fallback needs reordering; a chip is written at
+        // offset 0 directly, and shifting text afterwards would corrupt it.
+        if (!usedChip) {
+          try {
+            const actx = pluginCtx?.sessions?.scope?.(sessionId);
+            const input = actx === undefined || actx === null ? undefined : pluginCtx?.conversation?.input?.for?.(actx);
+            const snapshot = input?.draftSnapshot;
+            const noChips = Array.isArray(snapshot?.references) && snapshot.references.length === 0;
+            if (noChips && typeof snapshot.text === 'string') {
+              const index = snapshot.text.lastIndexOf(marker);
+              const before = index > 0 ? snapshot.text.slice(0, index).replace(/\s+$/, '') : '';
+              if (index > 0 && before.length > 0) {
+                const after = snapshot.text.slice(index + marker.length);
+                input.setDraft({ text: `${marker}\n${before}${after}`, references: [] });
+              }
+            }
+          } catch {
+            report('reorder-skipped', { messageId });
+          }
+        }
+
+        // Record the id -> session pair before the marker leaves the client, so
+        // `quote_read` can resolve the owner instead of guessing a live agent.
+        postHint(messageId, sessionId);
+
         replaceQuote(sessionId, {
           id: `${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
           preview: previewOf(text),
@@ -672,14 +1018,229 @@ window.__ModuleLoader__.load({
       );
     }
 
+    /**
+     * The one-line marker this plugin puts in the composer.
+     *
+     * Group 1 is the message id. Kept in sync with the string built in
+     * QuoteActions; the quote em-dash is part of the contract.
+     */
+    const QUOTE_MARK = /\[引用消息\s+([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\s*——[^\]]*\]/g;
+
+    /** Rule id for sent bubbles; must not collide with DSH's own user-text rules. */
+    const CARD_NODE = 'dsh-quote-shot-card';
+
+    /**
+     * userText rule: find one quote marker at or after `from`.
+     *
+     * DSH runs these rules over the text of a SENT user message and lets the
+     * plugin replace the matched span with a React node, which is how a plain
+     * `[引用消息 …]` turns into a card in the bubble.
+     */
+    const quoteRule = {
+      id: CARD_NODE,
+      order: 15,
+      match(text, from) {
+        QUOTE_MARK.lastIndex = from;
+        const m = QUOTE_MARK.exec(text);
+        if (m === null) return undefined;
+        return {
+          id: CARD_NODE,
+          start: m.index,
+          end: m.index + m[0].length,
+          data: { messageId: m[1] }
+        };
+      }
+    };
+
+    /**
+     * The card a sent quote renders as.
+     *
+     * It shows nothing about the quoted text until opened: the marker carries
+     * only an id, and prefetching the body for every card would fire a request
+     * per quote on every render. Opening asks the Host for the text once and
+     * caches it on the component.
+     *
+     * @param props - `node` from the rule (`data.messageId`, `data.text`/`note`).
+     * @returns the card element.
+     */
+    function SentQuoteCard(props) {
+      const node = props.node ?? {};
+      const messageId = String(node?.data?.messageId ?? '');
+      const [open, setOpen] = react.useState(false);
+      const [body, setBody] = react.useState(null);
+      const [state, setState] = react.useState('idle');
+      const [notice, setNotice] = react.useState(null);
+
+      const toggle = async () => {
+        if (open) {
+          setOpen(false);
+          return;
+        }
+        setOpen(true);
+        if (body !== null || state === 'loading') return;
+        setState('loading');
+        try {
+          const response = await fetch('/quote-shot/message', {
+            method: 'POST',
+            credentials: 'same-origin',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ messageId })
+          });
+          const payload = await response.json();
+          if (payload.ok === true) {
+            setBody(String(payload.text ?? ''));
+            setState('done');
+          } else {
+            setBody('（找不到这条消息的正文）');
+            setState('missing');
+          }
+        } catch {
+          setBody('（读取失败）');
+          setState('error');
+        }
+      };
+
+      const shortId = messageId.slice(0, 8);
+
+      const jump = () => {
+        if (jumpToMessage(messageId)) return;
+        // The row is gone: the virtualised list dropped it, or the page reloaded
+        // before any anchor was recorded for this id.
+        setNotice('原消息不在当前视图');
+        setTimeout(() => setNotice(null), 2200);
+      };
+
+      const header = h(
+        'span',
+        {
+          role: 'button',
+          tabIndex: 0,
+          onClick: jump,
+          onKeyDown: (event) => {
+            if (event.key === 'Enter' || event.key === ' ') {
+              event.preventDefault();
+              jump();
+            }
+          },
+          title: '点击回到原消息',
+          style: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: '6px',
+            padding: '3px 8px',
+            borderRadius: 'var(--dsw-radius-sm, 6px)',
+            cursor: 'pointer',
+            fontSize: '12px',
+            lineHeight: '16px',
+            color: 'color-mix(in srgb, currentColor 58%, transparent)'
+          }
+        },
+        h('span', { 'aria-hidden': 'true' }, '\u275D'),
+        h('span', null, `引用 ${shortId}`),
+        notice !== null ? h('span', { style: { opacity: 0.85 } }, notice) : null,
+        h(
+          'span',
+          {
+            role: 'button',
+            tabIndex: 0,
+            onClick: (event) => {
+              event.stopPropagation();
+              toggle();
+            },
+            onKeyDown: (event) => {
+              if (event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault();
+                event.stopPropagation();
+                toggle();
+              }
+            },
+            style: { marginLeft: 'auto', opacity: 0.7, cursor: 'pointer' }
+          },
+          open ? '收起' : state === 'loading' ? '读取中…' : '展开'
+        )
+      );
+
+      const children = [header];
+
+      if (open) {
+        children.push(
+          h(
+            'span',
+            {
+              key: 'body',
+              style: {
+                display: 'block',
+                marginTop: '6px',
+                padding: '0 8px 4px',
+                maxHeight: '220px',
+                overflowY: 'auto',
+                whiteSpace: 'pre-wrap',
+                overflowWrap: 'anywhere',
+                fontSize: '13px',
+                lineHeight: '1.55',
+                color: 'color-mix(in srgb, currentColor 80%, transparent)'
+              }
+            },
+            state === 'loading' ? '…' : body ?? ''
+          )
+        );
+      }
+
+      return h(
+        'span',
+        {
+          style: {
+            display: 'block',
+            margin: '2px 0 6px',
+            borderLeft: '2px solid color-mix(in srgb, currentColor 35%, transparent)',
+            borderRadius: 'var(--dsw-radius-sm, 6px)',
+            background: 'color-mix(in srgb, currentColor 6%, transparent)',
+            userSelect: 'text'
+          }
+        },
+        ...children
+      );
+    }
+
     /**
      * Register the dictionaries, the message action and the composer cards.
      *
      * @param ctx - the client plugin context.
      */
     function apply(ctx) {
+      pluginCtx = ctx;
       ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'quote-shot: dictionaries');
 
+      // The composer chip. It never offers completion candidates — it exists so
+      // the draft can carry a reference this plugin owns, which DSH draws as a
+      // compact tag instead of the raw instruction line.
+      ctx.effect(
+        () =>
+          ctx.inputTriggers.registerSource({
+            trigger: '@',
+            name: CHIP_SOURCE,
+            order: 99,
+            showGroupTitle: false,
+            candidates: () => Promise.resolve([]),
+            onPick: () => undefined,
+            openReference: () => undefined,
+            codec: {
+              clipboardText: (ref) => buildMarker(String(ref)),
+              serialize: (ref) => Promise.resolve(buildMarker(String(ref)))
+            }
+          }),
+        'quote-shot: chip source'
+      );
+
+      // Sent bubble: the marker becomes a card instead of a run of grey text.
+      ctx.effect(() => ctx.uiConversation.userText.register(quoteRule), 'quote-shot: user-text rule');
+      ctx.slots.inject('conversation.user.text.node', () =>
+        ctx.slots.register(
+          { name: 'conversation.user.text.node', key: CARD_NODE, priority: 100 },
+          SentQuoteCard
+        )
+      );
+
       ctx.slots.inject('conversation.chat.assistant-actions', () =>
         ctx.slots.register(
           {
@@ -711,9 +1272,10 @@ window.__ModuleLoader__.load({
     }
 
     exports.apply = apply;
-    exports.inject = ['slots', 'locale'];
+    exports.inject = ['slots', 'locale', 'uiConversation', 'conversation', 'sessions', 'inputTriggers'];
     exports.QuoteActions = QuoteActions;
     exports.QuoteCard = QuoteCard;
+    exports.SentQuoteCard = SentQuoteCard;
     exports.readQuoteText = readQuoteText;
     exports.previewOf = previewOf;
     exports.injectQuote = injectQuote;

package/index.js

@@ -16,7 +16,7 @@ import { appendFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { readMessageById } from './session-reader.js';
+import { readMessageById, readMessageFromFile, listRecentSessionFiles } from './session-reader.js';
 
 /**
  * Diagnostic log path.
@@ -55,7 +55,44 @@ export const inject = ['webServer', 'agents', 'tools'];
 /** Route owned by this plugin. */
 const ROUTE = '/quote-shot/inject';
 
-/** Longest accepted quote body, so one call cannot flood the context. */
+/**
+ * Route where the client reports which session a quote id belongs to.
+ *
+ * This is the one piece of knowledge the Host cannot recover reliably: the
+ * click happens in a known session, but `quote_read` runs later with no session
+ * context at all. Remembering the click's sessionId turns "guess which live
+ * agent is calling" into a direct lookup.
+ */
+const HINT_ROUTE = '/quote-shot/hint';
+
+/**
+ * messageId -> sessionId, filled by the client when a quote is placed.
+ *
+ * Bounded: a long session can quote many messages, and only recent quotes are
+ * plausibly still unread. Oldest entries fall out first (Map preserves order).
+ */
+const quoteHints = new Map();
+const MAX_HINTS = 200;
+
+/**
+ * Remember which session a quoted message belongs to.
+ *
+ * @param messageId - quoted message id.
+ * @param sessionId - session the quote button was clicked in.
+ */
+function rememberHint(messageId, sessionId) {
+  if (messageId.length === 0 || sessionId.length === 0) return;
+  quoteHints.delete(messageId);
+  quoteHints.set(messageId, sessionId);
+  if (quoteHints.size > MAX_HINTS) {
+    const oldest = quoteHints.keys().next().value;
+    quoteHints.delete(oldest);
+  }
+}
+
+/**
+ * Longest accepted quote body, so one call cannot flood the context.
+ */
 const MAX_TEXT_CHARS = 20_000;
 /** Longest accepted summary line shown in the collapsed row. */
 const MAX_SUMMARY_CHARS = 200;
@@ -111,6 +148,76 @@ function buildSummary(text) {
  *
  * @param ctx - the Host plugin context.
  */
+/**
+ * Locate one message's full text, in three tiers.
+ *
+ * Shared by the `quote_read` tool (the model) and `/quote-shot/message` (the
+ * client, which draws the sent-message card). Both need the same answer, so the
+ * search lives here instead of being duplicated.
+ *
+ * @param ctx - the Host plugin context (for the live-agent registry).
+ * @param messageId - the message id to find.
+ * @returns `{ text, via, sessionId }`, or null when nothing matched.
+ */
+function resolveMessageText(ctx, messageId) {
+  const startedAt = Date.now();
+  const tried = [];
+
+  // 1. The session the client reported when the quote was placed. This is the
+  //    exact answer, and the only step that works when the caller is not the
+  //    session that owns the message.
+  const hinted = quoteHints.get(messageId);
+  if (typeof hinted === 'string' && hinted.length > 0) {
+    tried.push(hinted);
+    const text = readMessageById(hinted, messageId);
+    if (text !== null) {
+      trace(`lookup session=${hinted} message=${messageId} len=${text.length} via=hint`);
+      return { text, via: 'hint', sessionId: hinted };
+    }
+  }
+
+  // 2. Every live agent, newest first. Background subagents are live agents
+  //    too, so "the last one" is not a safe guess.
+  let live = [];
+  try {
+    live = ctx.agents.list();
+  } catch {
+    live = [];
+  }
+  for (let index = live.length - 1; index >= 0; index -= 1) {
+    const sessionId = live[index]?.session?.id;
+    if (typeof sessionId !== 'string' || sessionId.length === 0) continue;
+    if (tried.includes(sessionId)) continue;
+    tried.push(sessionId);
+    const text = readMessageById(sessionId, messageId);
+    if (text !== null) {
+      trace(`lookup session=${sessionId} message=${messageId} len=${text.length} via=live`);
+      return { text, via: 'live', sessionId };
+    }
+  }
+
+  // 3. On-disk scan of the most recently used logs: covers a restarted DSH or a
+  //    conversation that is no longer live. Message ids are UUIDs.
+  let sources = [];
+  try {
+    sources = listRecentSessionFiles(25);
+  } catch {
+    sources = [];
+  }
+  for (const source of sources) {
+    const text = readMessageFromFile(source.file, messageId);
+    if (text !== null) {
+      trace(`lookup session=${source.sessionId} message=${messageId} len=${text.length} via=scan`);
+      return { text, via: 'scan', sessionId: source.sessionId };
+    }
+  }
+
+  // Failure MUST be traced. Silently returning "not found" is exactly how the
+  // earlier bug stayed invisible.
+  trace(`lookup MISS message=${messageId} tried=[${tried.join(', ')}] scanned=${sources.length} ms=${Date.now() - startedAt}`);
+  return null;
+}
+
 export function apply(ctx) {
   ctx.effect(
     () =>
@@ -232,6 +339,86 @@ export function apply(ctx) {
     'quote-shot: client log route'
   );
 
+  // Client hint sink: which session the quote was placed in.
+  //
+  // Fire-and-forget from the client. A missed hint only costs a slower lookup
+  // (the registry and the on-disk scan still run), so failures are silent.
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: 'exact',
+        path: HINT_ROUTE,
+        handler: async (request, response) => {
+          const reply = (status, body) => {
+            response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+            response.end(JSON.stringify(body));
+          };
+          if (request.method !== 'POST') {
+            response.writeHead(405, { allow: 'POST' });
+            response.end();
+            return;
+          }
+          const body = await readJson(request);
+          if (body === null) {
+            reply(400, { ok: false, code: 'bad-json' });
+            return;
+          }
+          const messageId = typeof body.messageId === 'string' ? body.messageId.trim() : '';
+          const sessionId = typeof body.sessionId === 'string' ? body.sessionId.trim() : '';
+          if (messageId.length === 0 || sessionId.length === 0) {
+            reply(400, { ok: false, code: 'missing-fields' });
+            return;
+          }
+          rememberHint(messageId, sessionId);
+          trace(`hint message=${messageId} session=${sessionId}`);
+          reply(200, { ok: true });
+        }
+      }),
+    'quote-shot: hint route'
+  );
+
+  // Client-side message text lookup, for the sent-message card.
+  //
+  // The card shows the quoted body when opened, but the renderer cannot call a
+  // model tool. This exposes the same three-tier lookup over HTTP so the card
+  // does not have to duplicate any of it.
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: 'exact',
+        path: '/quote-shot/message',
+        handler: async (request, response) => {
+          const reply = (status, body) => {
+            response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+            response.end(JSON.stringify(body));
+          };
+          if (request.method !== 'POST') {
+            response.writeHead(405, { allow: 'POST' });
+            response.end();
+            return;
+          }
+          const body = await readJson(request);
+          if (body === null) {
+            reply(400, { ok: false, code: 'bad-json' });
+            return;
+          }
+          const messageId = typeof body.messageId === 'string' ? body.messageId.trim() : '';
+          if (messageId.length === 0) {
+            reply(400, { ok: false, code: 'missing-messageId' });
+            return;
+          }
+          const found = resolveMessageText(ctx, messageId);
+          if (found === null) {
+            reply(200, { ok: false, code: 'not-found' });
+            return;
+          }
+          trace(`card message=${messageId} len=${found.text.length} via=${found.via}`);
+          reply(200, { ok: true, text: found.text });
+        }
+      }),
+    'quote-shot: message route'
+  );
+
   // The `quote_read` tool: read a message's full text by id.
   //
   // This is what makes "quote by reference" possible — the composer carries only
@@ -294,26 +481,9 @@ export function apply(ctx) {
           async execute(args) {
             const messageId = typeof args?.messageId === 'string' ? args.messageId.trim() : '';
             if (messageId.length === 0) return { found: false, messageId: '', error: 'missing-messageId' };
-
-            let live = [];
-            try {
-              live = ctx.agents.list();
-            } catch {
-              live = [];
-            }
-            if (live.length === 0) return { found: false, messageId, error: 'no-active-conversation' };
-
-            // Most recently registered live agent is the one issuing this call.
-            const owner = live[live.length - 1];
-            const sessionId = owner?.session?.id;
-            if (typeof sessionId !== 'string' || sessionId.length === 0) {
-              return { found: false, messageId, error: 'no-session-id' };
-            }
-
-            const text = readMessageById(sessionId, messageId);
-            if (text === null) return { found: false, messageId, error: 'not-found' };
-            trace(`quote_read session=${sessionId} message=${messageId} len=${text.length}`);
-            return { found: true, messageId, text };
+            const found = resolveMessageText(ctx, messageId);
+            if (found === null) return { found: false, messageId, error: 'not-found' };
+            return { found: true, messageId, text: found.text };
           }
         });
         trace('tool quote_read registered');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-quote-shot",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Quote a whole DSH message by reference: the composer carries only a message id, and the model reads the full text on demand through a quote_read tool instead of pasting it into the prompt.",
   "type": "module",
   "main": "index.js",

package/session-reader.js

@@ -25,9 +25,29 @@ const SESSIONS_ROOT = join(homedir(), '.dsh', 'sessions');
 /** Zstd frame magic number. */
 const MAGIC = [0x28, 0xb5, 0x2f, 0xfd];
 
-/** Per-session cache: sessionId -> { mtimeMs, index }. */
+/** Per-file cache: absolute log path -> { mtimeMs, index }. */
 const cache = new Map();
 
+/** Log file name inside a session directory. */
+const LOG_NAME = 'session.v4.jsonl.zstd';
+
+/**
+ * Directory names one session log may live under.
+ *
+ * DSH is not consistent here: sessions created by the desktop UI are stored as
+ * `session-<uuid>`, while subagent sessions and older logs use a bare `<uuid>`.
+ * On this machine that was 12 prefixed vs 161 bare logs in ONE workspace slug,
+ * so matching only the prefixed form silently missed almost every session.
+ *
+ * @param sessionId - bare session uuid, with or without the `session-` prefix.
+ * @returns candidate directory names, most likely first.
+ */
+function sessionDirCandidates(sessionId) {
+  const bare = String(sessionId).replace(/^session-/, '');
+  if (bare.length === 0) return [];
+  return [`session-${bare}`, bare];
+}
+
 /**
  * Locate the durable log file for one session.
  *
@@ -38,21 +58,63 @@ const cache = new Map();
  * @returns absolute path, or null when no log exists.
  */
 export function findSessionFile(sessionId) {
-  const bare = String(sessionId).replace(/^session-/, '');
-  if (bare.length === 0 || !existsSync(SESSIONS_ROOT)) return null;
+  if (!existsSync(SESSIONS_ROOT)) return null;
   let slugs;
   try {
     slugs = readdirSync(SESSIONS_ROOT);
   } catch {
     return null;
   }
-  for (const slug of slugs) {
-    const file = join(SESSIONS_ROOT, slug, `session-${bare}`, 'session.v4.jsonl.zstd');
-    if (existsSync(file)) return file;
+  for (const dir of sessionDirCandidates(sessionId)) {
+    for (const slug of slugs) {
+      const file = join(SESSIONS_ROOT, slug, dir, LOG_NAME);
+      if (existsSync(file)) return file;
+    }
   }
   return null;
 }
 
+/**
+ * Every session log under the sessions root, newest first.
+ *
+ * Used as the last-resort lookup: a quoted message can be older than the set of
+ * live agents (DSH restarted, or the conversation was reopened from history), so
+ * the owning session has to be found on disk rather than in the registry.
+ *
+ * @param limit - how many of the most recently touched logs to return.
+ * @returns `{ sessionId, file, mtimeMs }` entries, newest first.
+ */
+export function listRecentSessionFiles(limit = 25) {
+  if (!existsSync(SESSIONS_ROOT)) return [];
+  const found = [];
+  let slugs;
+  try {
+    slugs = readdirSync(SESSIONS_ROOT);
+  } catch {
+    return [];
+  }
+  for (const slug of slugs) {
+    let dirs;
+    try {
+      dirs = readdirSync(join(SESSIONS_ROOT, slug));
+    } catch {
+      continue;
+    }
+    for (const dir of dirs) {
+      const file = join(SESSIONS_ROOT, slug, dir, LOG_NAME);
+      let stat;
+      try {
+        stat = statSync(file);
+      } catch {
+        continue;
+      }
+      found.push({ sessionId: dir.replace(/^session-/, ''), file, mtimeMs: stat.mtimeMs });
+    }
+  }
+  found.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  return found.slice(0, Math.max(1, limit));
+}
+
 /**
  * Decompress every zstd frame in a multi-frame buffer.
  *
@@ -122,24 +184,25 @@ function textOf(data) {
 }
 
 /**
- * Build (or reuse) the id → text index for one session.
+ * Build (or reuse) the id → text index for one log file.
  *
  * A single message id can appear across several events (streaming parts), so
  * text is accumulated per id rather than overwritten.
  *
- * @param sessionId - session whose log to index.
+ * Cached by FILE PATH, not session id: the same log can be reached through a
+ * prefixed and a bare directory name, and keying by id would build it twice.
+ *
+ * @param file - absolute log path.
  * @returns the index, or null when the log cannot be read.
  */
-function indexFor(sessionId) {
-  const file = findSessionFile(sessionId);
-  if (file === null) return null;
+function indexForFile(file) {
   let mtimeMs;
   try {
     mtimeMs = statSync(file).mtimeMs;
   } catch {
     return null;
   }
-  const cached = cache.get(sessionId);
+  const cached = cache.get(file);
   if (cached !== undefined && cached.mtimeMs === mtimeMs) return cached.index;
 
   let raw;
@@ -166,12 +229,26 @@ function indexFor(sessionId) {
     const previous = index.get(id);
     index.set(id, previous === undefined ? body : `${previous}\n${body}`);
   }
-  cache.set(sessionId, { mtimeMs, index });
+  cache.set(file, { mtimeMs, index });
   return index;
 }
 
 /**
- * Read one message's full text by id.
+ * Read one message's text out of a specific log file.
+ *
+ * @param file - absolute log path.
+ * @param messageId - the message id.
+ * @returns the text, or null when the id is not in that log.
+ */
+export function readMessageFromFile(file, messageId) {
+  if (typeof file !== 'string' || typeof messageId !== 'string') return null;
+  const index = indexForFile(file);
+  if (index === null) return null;
+  return index.get(messageId) ?? null;
+}
+
+/**
+ * Read one message's full text by id, from its owning session.
  *
  * @param sessionId - owning session (bare uuid or `session-`-prefixed).
  * @param messageId - the message id.
@@ -179,9 +256,9 @@ function indexFor(sessionId) {
  */
 export function readMessageById(sessionId, messageId) {
   if (typeof sessionId !== 'string' || typeof messageId !== 'string') return null;
-  const index = indexFor(sessionId);
-  if (index === null) return null;
-  return index.get(messageId) ?? null;
+  const file = findSessionFile(sessionId);
+  if (file === null) return null;
+  return readMessageFromFile(file, messageId);
 }
 
 /**

package/test.mjs

@@ -242,6 +242,8 @@ console.log('\napply() wiring');
   const localeRegs = [];
   const slotInjections = [];
   const seats = [];
+  const sources = [];
+  const rules = [];
   const ctx = {
     effect(fn) {
       return fn();
@@ -261,14 +263,43 @@ console.log('\napply() wiring');
       register(spec, component) {
         return { spec, component };
       }
-    }
+    },
+    // Services added by the card / chip work. The mock has to model them, or
+    // apply() throws on the first dereference and every later check is noise.
+    inputTriggers: {
+      registerSource(source) {
+        sources.push(source);
+        return () => {};
+      }
+    },
+    uiConversation: {
+      userText: {
+        register(rule) {
+          rules.push(rule);
+          return () => {};
+        }
+      }
+    },
+    conversation: { input: { for: () => undefined } },
+    sessions: { scope: () => null }
   };
   api.apply(ctx);
   check('registers the dictionaries', localeRegs.length === 1 && localeRegs[0].namespace === 'quoteShot', JSON.stringify(localeRegs.map((r) => r.namespace)));
   check('dictionaries carry zh and en', Boolean(localeRegs[0]?.dictionaries?.zh && localeRegs[0]?.dictionaries?.en));
-  check('injects into two slots', slotInjections.length === 2, slotInjections.join(','));
-  check('first seat is the message action', slotInjections[0] === 'conversation.chat.assistant-actions', slotInjections[0]);
-  check('second seat is the composer dock', slotInjections[1] === 'conversation.input.dock', slotInjections[1]);
+  check('registers the chip source', sources.length === 1 && sources[0].name === 'quote-shot', JSON.stringify(sources.map((s) => s.name)));
+  check(
+    'chip codec covers clipboard and serialize',
+    typeof sources[0]?.codec?.clipboardText === 'function' && typeof sources[0]?.codec?.serialize === 'function'
+  );
+  check(
+    'chip serialises to the same marker',
+    sources[0]?.codec?.clipboardText('abcdefgh-0000-0000-0000-000000000000')?.startsWith('[引用消息 abcdefgh-') === true
+  );
+  check('registers the user-text rule', rules.length === 1 && rules[0].id === 'dsh-quote-shot-card', String(rules[0]?.id));
+  check('injects into three slots', slotInjections.length === 3, slotInjections.join(','));
+  check('seat order: user text, message action, composer dock', slotInjections[0] === 'conversation.user.text.node', slotInjections[0]);
+  check('second seat is the message action', slotInjections[1] === 'conversation.chat.assistant-actions', slotInjections[1]);
+  check('third seat is the composer dock', slotInjections[2] === 'conversation.input.dock', slotInjections[2]);
   const actionSeat = seats.find((s) => s?.spec?.id === 'quote');
   const cardSeat = seats.find((s) => s?.spec?.id === 'quote-card');
   check('registers the action component', actionSeat?.component === api.QuoteActions);