dsh-agent-message 1.5.0 → 1.6.0

package/README.en.md

@@ -12,8 +12,8 @@ English | [中文](./README.md)
 
 In DeepSeek Harness, a single process hosts multiple Agent sessions at once. This plugin equips each session with three tools so they can "message" each other:
 
-- Before sending, first **list every sendable session** (all non-archived ones are listed, including offline ones that haven't been reopened), and find the target by its title;
-- Once found, **deliver the message to the target session** — ordinary messages always enter a new independent turn; if the target is offline (not loaded since the last process restart), the plugin resumes it through Harness's public API, delivers the message, and releases the runtime after processing;
+- Before sending, first **list every sendable independent session** (non-archived, excluding actual subagents, including offline sessions that have not been reopened), and find the target by its title;
+- Once found, **deliver the message to the target session** — ordinary messages always enter a new independent turn; if the target is offline (not loaded since the last process restart), the plugin resumes it through Harness's public API, delivers the message, and keeps the handle loaded for later communication until plugin teardown;
 - When needed, **query the delivery status of a message on demand** (queued / claimed / discarded / unknown), with the target runtime status reported separately for supervision scenarios.
 
 Typical scenarios: an orchestrator Agent dispatching work to a developer Agent, two Agents collaborating in a relay, a main session sending instructions to a test session, or a supervisor Agent watching over several workers.
@@ -25,15 +25,16 @@ Typical scenarios: an orchestrator Agent dispatching work to a developer Agent,
 | `list_peer_agents` | List all **sendable independent sessions**: non-archived, excluding actual subagents while retaining ordinary forks; returns id, title, working directory, and runtime status |
 | `send_agent_message` | Send a message to a session id; `followup` creates an independent turn by default and offline targets are resumed automatically; explicit modes are `followup`, `inject`, and `steer` |
 | `check_delivery` | Query receipts on demand (pending/claimed/discarded/unknown); a successful send first returns accepted, while pre-admission failure is a tool error; explicit message ids remain queryable after restart |
-| `@` session locator | Type `@` at the beginning of the composer and choose a target; candidates show only the session title and `Running`/`Idle`, excluding blank placeholders and subagents. The user sees a readable title while the current Agent receives the stable session id; `@` only locates the session, and the full-sentence intent determines whether to send, read, or analyze |
-| Visible Agent message card | Relay keeps its true plugin provenance while the Client presents it as a left-aligned Agent message card; `From Session · <name>:` opens the sender by click or keyboard |
+| Native Harness `@` session reference | Reuse Harness's structured Session Reference directly. The current Agent receives the stable Session ID plus a bounded, read-only snapshot marked as untrusted. Referencing alone does not send a message or wake the target |
+| Visible Agent message card | Relay keeps its true plugin provenance while the Client presents it as a left-aligned Agent message card; `From Session · <name>:` opens the sender by click or keyboard, with labels following the Harness language setting |
 | Copy session id | A "Copy ID" button is added to the session header for one-click copying of the current session id |
+| Delivery card settings | In Settings → Plugin configuration, toggle delivery mode and target runtime details; `messageId` is always shown |
 
 ### Sender navigation example
 
 ![Clickable sender header example](./docs/assets/message-header-navigation.jpg)
 
-The image shows navigation on a historical `user` bubble. Current relay messages use the same visible-card and sender-navigation experience while retaining plugin `relay` provenance instead of impersonating human input. The full session id remains in typed source metadata and in a Host-generated model-visible protocol header, so the receiving Agent never has to guess the sender.
+Current relay messages are displayed as visible Agent message cards; clicking the header opens the sender session. The persisted source remains plugin `relay` provenance rather than impersonating human input. The full session id remains in typed source metadata and in a Host-generated model-visible protocol header, so the receiving Agent never has to guess the sender.
 
 ### Delivery modes (the `mode` parameter of `send_agent_message`)
 
@@ -55,7 +56,7 @@ dsh plugin --profile web add dsh-agent-message
 
 It self-registers on install; no extra configuration is needed.
 
-Compatibility: Node.js 24 and DeepSeek Harness `>=0.1.0-rc.6 <0.2.0`; currently verified with Node.js `24.x` and Harness `0.1.0-rc.6`.
+Compatibility: Node.js 24 and DeepSeek Harness `>=0.1.1-rc.2 <0.2.0`; currently verified with Node.js `24.x` and Harness `0.1.1-rc.2`.
 
 ### Option 2: Install from GitHub
 
@@ -77,9 +78,9 @@ The plugin ships a `cordis.patch.yml` (pointed to by `dsh.bundle.patch` in `pack
 
 ## Usage
 
-1. Type `@` at the beginning of session A's composer and choose the target from the native candidate menu; each candidate shows its title and `Running`/`Idle` activity;
-2. `@` only tells A where the relevant session is; it does not mean send. A calls `send_agent_message` when either the current request or an orchestration responsibility already granted by the user requires cross-session communication, and makes that routing decision silently. For example, `@B tell it to stop after opening the draft PR` sends, while `@B analyze its latest conversation result` only reads B on demand without explaining the internal routing decision;
-3. For an explicit forwarding request, A only delivers and reports the result. It must not execute the forwarded task itself or ask B for an extra acknowledgement. B sends a business result to `senderSessionId` only when the body explicitly asks for one;
+1. Type `@` in session A's composer and choose the target session from Harness's native candidate menu;
+2. Harness gives A a bounded, read-only, untrusted snapshot of that Session, but does not message or wake B. A calls `send_agent_message` only when the current request or an orchestration responsibility already granted by the user explicitly requires cross-session communication. For example, `@B tell it to stop after opening the draft PR` sends, while `@B analyze its latest conversation result` only uses the referenced snapshot;
+3. For an explicit forwarding request, A only delivers and reports whether the message was accepted or failed. It must not execute the forwarded task itself or ask B for an extra acknowledgement. B sends a message to `senderSessionId` only when the body explicitly asks it to return business content;
 4. You can still ask the Agent to call `list_peer_agents` and send directly with a full session id;
 5. Session B receives a native `UserMessage` with a typed relay source plus a minimal Host-generated source header on the first body line, so B does not have to guess the sender. The Client presents it as a visible Agent message card whose header opens the sender session;
 6. (Supervision) Say "check the status of my messages to `<session id>`" — it calls `check_delivery`.
@@ -99,13 +100,15 @@ Delivery paths of `send_agent_message`:
 
 Session enumeration, batched titles, and offline log reads use Harness's `sessionQuery.listSessions()`, `readTitleSnapshots()`, and `readSession()` respectively. `SessionId` is the only address; `parentSession` records fork lineage only, and only `origin: subagent` identifies an actual subagent. The plugin does not scan `sessionPersistence` directly to rebuild a parallel session directory.
 
-After `send_agent_message` submits the native message to the target Inbox, it immediately returns `accepted` with the native `messageId`. `check_delivery` then derives `pending` (still queued), `claimed` (claimed by a turn), `discarded` (cancelled), or `unknown` from Inbox events. `claimed` is transport evidence only: it does not prove that the message was read, answered, or completed. Pre-admission failure remains a Harness tool error and writes nothing to the target Inbox. Runtime state is reported separately as `targetRuntimeStatus`, so unrelated Agent activity never changes the message state. A known `messageId` remains queryable from the target Inbox log after a process restart.
+After `send_agent_message` submits the native message to the target Inbox, it immediately returns `accepted` with the native `messageId`; both the terse tool result and the full tool card show a selectable `messageId` for copying, while the complete result also stays in tool presentation metadata. `check_delivery` then derives `pending` (still queued), `claimed` (claimed by a turn), `discarded` (cancelled), or `unknown` from Inbox events on demand. `claimed` is transport evidence only: it does not prove that the message was read, answered, or completed. Pre-admission failure remains a Harness tool error and writes nothing to the target Inbox. Runtime state is reported separately as `targetRuntimeStatus`, so unrelated Agent activity never changes the message state. A known `messageId` remains queryable from the target Inbox log after a process restart.
 
 Every cross-session message is created by Harness `createUserMessage()`, and `UserMessage.id` is its only message identity. Its source always uses `kind: dsh-agent-message` and `form: relay`, plus the protocol version, sender/target Session ids, and display title. Because current Harness model requests do not expand custom source fields, the Host also writes a minimal `<dsh-agent-message>` header containing only `senderSessionId` on the first body line. The typed source is the durable/UI truth; the header is only the model-visible projection needed for reply addressing. The plugin registers no global system prompt; send admission lives only in the `send_agent_message` tool contract. The Client only projects relay as a visible Agent message card and never rewrites an Agent message as human `user` provenance.
 
-The current release has no separate result protocol: relay only means “a message addressed by another session”; it neither requires nor forbids a reply. When the body explicitly requests a business result, the receiving Agent may send it to `senderSessionId` with the same tool. Otherwise it must not send a transport acknowledgement or a bare “received.” A correlated Result protocol should be added only when machine-verifiable request/result linkage is required.
+Relay only means “a message addressed by another session”; it neither requires nor forbids a reply. When the body explicitly requests business content in return, the receiving Agent may send a message to `senderSessionId` with the same tool. Otherwise it must not send a transport acknowledgement or a bare “received.” The plugin does not automatically correlate requests and replies or forward ordinary Agent answers.
 
-The composer-side `@` session locator reuses Harness's native `inputTriggers` command marker. The visible selected title is capped at 40 Unicode characters with an ellipsis; submission replaces it with the full stable `@session-...` id for the current Agent. The sent bubble still projects that id with a chat icon and the live session title, so renaming a session does not change the locator target.
+Composer-side `@` is provided entirely by Harness's native `ui-reference` / `session-reference` services. Harness retains the stable Session ID in the structured reference and owns bounded snapshot loading and injection. The plugin no longer registers an `@` source, parses titles for addressing, or maintains a second session-reference UI.
+
+See [`docs/architecture-v2.md`](./docs/architecture-v2.md) for the current architecture contract.
 
 ## Directory structure
 
@@ -113,21 +116,30 @@ The composer-side `@` session locator reuses Harness's native `inputTriggers` co
 dsh-agent-message/
 ├── lib/
 │   ├── index.js        # host half: list_peer_agents / send_agent_message / check_delivery
-│   └── client.js       # client half: @session references, session navigation and copy-session-id button
+│   └── client.js       # client half: relay display, sender navigation, settings, and copy-session-id button
 ├── cordis.patch.yml    # self-registration patch (pointed to by dsh.bundle.patch)
 ├── package.json        # DSH plugin manifest (dsh.bundle / dsh.client / dshx.contributes)
-├── docs/               # design notes and README example screenshot
+├── docs/               # active/proposed architecture and README example screenshot
+├── scripts/web-smoke.mjs # real Web Profile startup and configuration smoke test
 ├── README.md           # Chinese documentation
 └── README.en.md        # English documentation
 ```
 
-## In Development
+## Development validation
+
+```sh
+pnpm test
+pnpm run test:web-smoke
+pnpm peers check
+```
 
-- **Cross-process communication:** Allow Agent sessions running in different DSH processes to exchange messages.
+`test:web-smoke` requires a local `dsh` installation and a configured Web Profile. It checks startup, plugin composition, and HTTP reachability only; see the [architecture validation record](./docs/architecture-v2.md#14-验证记录) for real interaction coverage.
 
 ## Limitations
 
 - The target session must be **non-archived** and present in local persistence; archived sessions are always rejected.
+- These tools are only for communication between independent sessions; actual subagents are neither listed as targets nor allowed to call them.
+- One Session pair, regardless of direction, may receive at most 10 deliveries in a rolling 60-second window. The 11th is rejected before the target Inbox is changed. This window belongs to the current Harness process and resets on restart.
 - Automatically resuming an offline session uses the **default model** (it does not inherit a model manually selected earlier in that session); if resume fails, the message is not written to the target Inbox.
 - Bulk receipt queries without `messageId` rely on in-memory bookkeeping and cover only the most recent 1000 sends in the current process (FIFO eviction). After a restart, a known `messageId` remains queryable, but the volatile `sentAt` and `mode` fields are no longer returned.
 - Cross-process / cross-machine communication is out of scope.

package/README.md

@@ -12,8 +12,8 @@
 
 在 DeepSeek Harness 里，一个进程会同时挂着多个 Agent 会话。本插件给每个会话装上三个工具，让它们能互相"发消息"：
 
-- 发消息前，先**列出所有可发送的会话**（未归档的都在列，含离线未打开的），按标题找到目标；
-- 找到后，**把消息投递到目标会话**——普通消息统一进入独立的新 turn；目标离线（进程重启后还没打开）时，插件通过 Harness 公开接口恢复会话、投递，并在处理结束后释放 runtime；
+- 发消息前，先**列出所有可发送的独立会话**（未归档、排除真实子代理，含离线未打开的），按标题找到目标；
+- 找到后，**把消息投递到目标会话**——普通消息统一进入独立的新 turn；目标离线（进程重启后还没打开）时，插件通过 Harness 公开接口恢复会话、投递，并保持加载供后续通信，插件卸载时再释放 handle；
 - 需要时，可以**按需查询**某条消息的送达状态（排队中/已认领/被丢弃/未知），并单独查看目标是否正在运行，供监督场景使用。
 
 典型场景：编排者 Agent 给开发 Agent 派活、两个 Agent 协作接力、主会话给测试会话发指令、监督者 Agent 盯梢多个 worker。
@@ -25,15 +25,16 @@
 | `list_peer_agents` | 列出所有**可发送**的独立会话：未归档、排除真实子代理；普通 fork 保留。返回 id、标题、工作目录和运行状态 |
 | `send_agent_message` | 给指定会话 ID 发消息；默认使用 `followup` 创建独立的新 turn，离线时自动恢复后投递；显式支持 `followup`、`inject`、`steer` |
 | `check_delivery` | 按需查询消息回执（pending/claimed/discarded/unknown）；发送成功时先返回 accepted，接纳前失败由工具错误表示；指定消息 ID 时支持重启后恢复查询 |
-| `@` 会话定位 | 在输入框开头键入 `@` 选择目标；候选只显示会话标题和“运行中/空闲”，空白占位和子代理不混入。选择后用户看到可读标题，当前 Agent 收到稳定 session ID；`@` 只定位，发送、读取或分析由整句意图决定 |
-| 可见的 Agent 消息卡片 | relay 仍保留真实的插件来源，但 Client 将它显示为左侧 Agent 消息卡片；`From Session · <名称>:` 可点击或通过键盘打开发送方会话 |
+| Harness 原生 `@` 会话引用 | 直接复用 Harness 的结构化 Session Reference；选择后当前 Agent 获得稳定 Session ID 和一份有界、只读、标记为不可信的会话快照。引用本身不会发送消息或唤醒目标 |
+| 可见的 Agent 消息卡片 | relay 仍保留真实的插件来源，但 Client 将它显示为左侧 Agent 消息卡片；`From Session · <名称>:` 可点击或通过键盘打开发送方会话，文案跟随 Harness 语言设置 |
 | 复制会话 ID | 会话头部新增「复制ID」按钮，一键复制当前会话 ID |
+| 投递卡片设置 | 在设置 → 插件配置中，可切换是否显示投递模式和目标运行状态；`messageId` 始终显示 |
 
 ### 发送方导航示例
 
 ![可点击的发送者消息头示例](./docs/assets/message-header-navigation.jpg)
 
-图中是历史 `user` 气泡的导航效果；当前 relay 消息使用相同的可见卡片和发送方跳转，但持久化来源仍是插件 `relay`，不会伪装成人类输入。完整会话 ID 同时保留在 typed source 和 Host 生成的模型可见协议头中，避免接收 Agent 猜测发送方。
+当前 relay 消息显示为可见的 Agent 消息卡片；点击消息头即可跳转到发送方会话。持久化来源仍是插件 `relay`，不会伪装成人类输入。完整会话 ID 同时保留在 typed source 和 Host 生成的模型可见协议头中，避免接收 Agent 猜测发送方。
 
 ### 投递模式（`send_agent_message` 的 `mode` 参数）
 
@@ -56,7 +57,7 @@ dsh plugin --profile web add dsh-agent-message
 
 装完即自动注册，无需任何额外配置。
 
-兼容范围：Node.js 24、DeepSeek Harness `>=0.1.0-rc.6 <0.2.0`；当前验证版本为 Node.js `24.x`、Harness `0.1.0-rc.6`。
+兼容范围：Node.js 24、DeepSeek Harness `>=0.1.1-rc.2 <0.2.0`；当前验证版本为 Node.js `24.x`、Harness `0.1.1-rc.2`。
 
 ### 方式二：从 GitHub 安装
 
@@ -78,9 +79,9 @@ Agent 会用 bash 执行这条命令，装完自动挂载、所有会话立即
 
 ## 使用
 
-1. 在会话 A 的输入框开头键入 `@`，从原生候选菜单中选择目标会话；候选会显示标题和“运行中/空闲”；
-2. `@` 只告诉 A 信息或操作的目标在哪里，不代表发送。当前请求或用户已授予的编排职责要求跨会话传递信息时，A 调用 `send_agent_message`并静默执行路由决策。例如 `@B 告诉他最后提交 PR draft 就停止` 会发送，`@B 帮我分析他最新的对话结果` 则只按需读取 B，不向用户解释内部路由判断；
-3. 显式要求转告时，A 只负责投递和报告结果，不代为执行被转发的任务，也不要求 B 额外回复“收到”；如果正文明确要求 B 把业务结果返回 A，B 才向 `senderSessionId` 发送结果；
+1. 在会话 A 的输入框中键入 `@`，从 Harness 原生候选菜单中选择目标会话；
+2. Harness 会把该 Session 的有界、只读、不可信快照提供给 A，但不会向 B 发消息或唤醒 B。只有当前请求或用户已授予的编排职责明确要求跨会话传递信息时，A 才调用 `send_agent_message`。例如 `@B 告诉他最后提交 PR draft 就停止` 会发送；`@B 帮我分析他最新的对话结果` 只使用引用快照；
+3. 显式要求转告时，A 只负责投递并报告“已接受”或失败，不代为执行被转发的任务，也不要求 B 额外回复“收到”；如果正文明确要求 B 把业务内容返回 A，B 才向 `senderSessionId` 发送消息；
 4. 也可以让 Agent 调 `list_peer_agents`，再用完整会话 ID 直接发送；
 5. 会话 B 收到的是带 typed relay source 的原生 `UserMessage`；正文首行还有 Host 生成的最小来源协议，B 不需要猜测发送方；Client 将其显示为可见 Agent 消息卡片，并可从消息头打开发送方会话；
 6. （监督场景）说「查一下我发给 `<会话ID>` 的消息状态」——它会调 `check_delivery`。
@@ -100,13 +101,15 @@ Agent 会用 bash 执行这条命令，装完自动挂载、所有会话立即
 
 会话枚举、批量标题和离线日志读取分别使用 Harness 的 `sessionQuery.listSessions()`、`readTitleSnapshots()` 与 `readSession()`。`SessionId` 是唯一地址；`parentSession` 只记录分叉血缘，只有 `origin: subagent` 才会被识别为真实子代理。插件不直接扫描 `sessionPersistence` 重建另一份会话目录。
 
-`send_agent_message` 成功把原生消息提交给目标 Inbox 后立即返回 `accepted` 和该消息的原生 `messageId`；`check_delivery` 根据 Inbox 事件返回 `pending`（仍在排队）、`claimed`（已被某轮认领）、`discarded`（被取消）或 `unknown`。`claimed` 只是传输证据，不表示已读、回复或任务完成。接纳前失败由 Harness 工具错误表示，不写入目标 Inbox。目标是否正在运行通过独立的 `targetRuntimeStatus` 返回，不把 Agent 的整体运行状态误当成某条消息正在处理。指定 `messageId` 时可从目标现有 Inbox 日志恢复状态，因此进程重启后仍可查询。
+`send_agent_message` 成功把原生消息提交给目标 Inbox 后立即返回 `accepted` 和该消息的原生 `messageId`；精简工具结果和完整工具卡片都会显示可选择复制的 `messageId`，完整结果同时保留在工具呈现元数据中。`check_delivery` 根据 Inbox 事件按需返回 `pending`（仍在排队）、`claimed`（已被某轮认领）、`discarded`（被取消）或 `unknown`。`claimed` 只是传输证据，不表示已读、回复或任务完成。接纳前失败由 Harness 工具错误表示，不写入目标 Inbox。目标是否正在运行通过独立的 `targetRuntimeStatus` 返回，不把 Agent 的整体运行状态误当成某条消息正在处理。指定 `messageId` 时可从目标现有 Inbox 日志恢复状态，因此进程重启后仍可查询。
 
 所有跨会话消息都由 Harness `createUserMessage()` 创建，`UserMessage.id` 是唯一消息身份。`source.kind` 固定为 `dsh-agent-message`，`form` 固定为 `relay`，并携带协议版本、发送/目标 Session 和显示标题。由于当前 Harness 不会把自定义 source 字段展开给模型，Host 还会在正文首行写入只含 `senderSessionId` 的最小 `<dsh-agent-message>` 协议头；source 是持久化/UI 真相，协议头只是回复寻址所需的模型可见投影。插件不注册全局系统提示词，发送准入只存在于 `send_agent_message` 的工具合同中。Client 只把 relay 投影为可见的 Agent 消息卡片，不会反向把 Agent 消息伪装成人类 `user` 来源。
 
-当前版本没有额外的结果协议：relay 只表达“另一会话发来的消息”，本身不等于必须回复或禁止回复。正文明确要求返回业务结果时，接收 Agent 可用同一工具向 `senderSessionId` 发送结果；没有明确要求时不回传 transport ack 或单纯的“收到”。需要机器可核验的请求/结果关联时，再引入独立 Result 协议。
+relay 只表达“另一会话发来的消息”，本身不等于必须回复或禁止回复。正文明确要求返回业务内容时，接收 Agent 可用同一工具向 `senderSessionId` 发送消息；没有明确要求时不回传 transport ack 或单纯的“收到”。插件不自动关联请求与回复，也不自动转发 Agent 的普通回答。
 
-输入框的 `@` 会话定位复用 Harness 原生 `inputTriggers` 命令标记：选择后的可见标题最多 40 个 Unicode 字符，超出用省略号；提交给当前 Agent 时换成完整 `@session-...` 稳定 ID。发送后的气泡依然用聊天图标和实时会话标题投影该 ID，显示名称变化不会改变定位目标。
+输入框的 `@` 完全由 Harness 原生 `ui-reference` / `session-reference` 提供，结构化引用保留稳定 Session ID，并由 Harness 负责读取和注入有界快照。插件不再注册自己的 `@` source、不解析标题寻址，也不维护第二套会话引用 UI。
+
+完整的现役架构合同见 [`docs/architecture-v2.md`](./docs/architecture-v2.md)。
 
 ## 目录结构
 
@@ -114,21 +117,30 @@ Agent 会用 bash 执行这条命令，装完自动挂载、所有会话立即
 dsh-agent-message/
 ├── lib/
 │   ├── index.js        # host 半区：list_peer_agents / send_agent_message / check_delivery
-│   └── client.js       # client 半区：@会话引用、会话导航与复制会话ID按钮
+│   └── client.js       # client 半区：relay 显示、发送方导航、设置与复制会话ID按钮
 ├── cordis.patch.yml    # 自注册补丁（dsh.bundle.patch 指向它）
 ├── package.json        # DSH 插件清单（dsh.bundle / dsh.client / dshx.contributes）
-├── docs/               # 设计稿与 README 示例截图
+├── docs/               # 现役/候选架构与 README 示例截图
+├── scripts/web-smoke.mjs # 真实 Web Profile 启动与配置冒烟
 ├── README.md           # 中文文档
 └── README.en.md        # English documentation
 ```
 
-## 正在开发
+## 开发验证
+
+```sh
+pnpm test
+pnpm run test:web-smoke
+pnpm peers check
+```
 
-- **跨进程通信**：让运行在不同 DSH 进程中的 Agent 会话也能互相收发消息。
+`test:web-smoke` 需要本机已安装 `dsh` 并配置 Web Profile，它只验证启动、插件组合和 HTTP 可达性；真实交互验收记录见 [`docs/architecture-v2.md`](./docs/architecture-v2.md#14-验证记录)。
 
 ## 限制
 
 - 目标会话必须**未归档**且存在于本机持久化里；归档会话一律拒绝发送。
+- 工具只用于独立 Session 之间通信；真实子代理既不会出现在目标列表中，也不能作为调用方使用这些工具。
+- 同一对 Session（不分发送方向）在滚动 60 秒内最多投递 10 条消息；第 11 条会在写入目标 Inbox 前被拒绝。该窗口只属于当前 Harness 进程，重启后清空。
 - 自动恢复离线会话时会使用**默认模型**（不继承它上次手动切换的模型选择）；恢复失败时消息不会被写入目标 Inbox。
 - 不指定 `messageId` 的批量回执依赖内存记账，只覆盖本进程最近 1000 条发送记录（FIFO 淘汰）；进程重启后仍可凭已知 `messageId` 查询，但不再返回易失的 `sentAt` 和 `mode`。
 - 跨进程/跨机器通信不在本插件范围内。

package/lib/client.js

@@ -5,152 +5,106 @@ window.__ModuleLoader__.load({
     var exports = module.exports;
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     const React = require("react");
-    const { createRoot } = require("react-dom/client");
-    const { IconQueueOutline14, StateDot } = require("@deepseek-ai/dsh-client-ui-primitives");
 
     const name = "dsh-agent-message-client";
-    const inject = ["slots", "timer", "sessions", "inputTriggers", "workspaces"];
+    const inject = ["slots", "timer", "sessions", "settingsScope", "locale"];
 
     function apply(ctx) {
-      const senderSelector = '[data-ref-chip="subagent"], [data-context-relay-sender]';
-      const referenceSource = "agent-message-session";
-      const candidateRows = new WeakMap();
-      const mountedRoots = new Map();
+      const senderSelector = "[data-context-relay-sender]";
       const sessionLinks = new Set();
-      const workspaces = ctx.get("workspaces");
+      const subscribeLocale = function (listener) { return ctx.locale.subscribe(listener); };
+      const getLocaleSnapshot = function () { return ctx.locale.getSnapshot(); };
 
-      function uiText(zh, en) {
-        const language = String(document.documentElement.lang || navigator.language || "zh").toLowerCase();
-        return language.startsWith("zh") ? zh : en;
-      }
-
-      function sessionRows(includeArchived) {
-        const snapshot = ctx.sessions.list.getSnapshot();
-        const archived = new Set(workspaces?.list.getSnapshot().archivedSessionIds || []);
-        return snapshot.ids
-          .map(function (id) { return snapshot.byId[id]; })
-          .filter(function (row) {
-            return row && !row.blank && row.origin !== "subagent"
-              && (includeArchived || !archived.has(row.id));
-          });
-      }
-
-      function sessionRow(id) {
-        return ctx.sessions.list.getSnapshot().byId[id];
-      }
-
-      function sessionTitle(row) {
-        return String(row?.displayTitle || row?.title || row?.id || "");
-      }
+      const AGENT_MESSAGE_SETTINGS_NAMESPACE = "agent-message";
 
-      function compactSessionTitle(row) {
-        const chars = Array.from(sessionTitle(row));
-        return chars.length > 40 ? chars.slice(0, 39).join("") + "…" : chars.join("");
+      function useLocale() {
+        React.useSyncExternalStore(subscribeLocale, getLocaleSnapshot);
       }
 
-      function renderInto(host, content) {
-        let root = mountedRoots.get(host);
-        if (!root) {
-          root = createRoot(host);
-          mountedRoots.set(host, root);
+      function AgentMessageSettingsCard(props) {
+        useLocale();
+        const snapshot = props.useAgentMessageSettings(function (value) { return value; });
+        const current = snapshot.value?.showTechnicalDetails !== false;
+        const [draft, setDraft] = React.useState(current);
+        const [saving, setSaving] = React.useState(false);
+        const [error, setError] = React.useState(false);
+        React.useEffect(function () { setDraft(current); }, [snapshot.revision, current]);
+        const dirty = draft !== current;
+        const writable = snapshot.writable && snapshot.status === "ready";
+        function save() {
+          if (!dirty || saving || !writable) return;
+          setSaving(true);
+          setError(false);
+          props.setShowTechnicalDetails(draft)
+            .catch(function () { setError(true); })
+            .finally(function () { setSaving(false); });
+        }
+        function reset() {
+          if (!writable) return;
+          setDraft(snapshot.base?.showTechnicalDetails !== false);
         }
-        root.render(content);
+        return React.createElement("section", { style: { padding: "12px 0", maxWidth: "760px" } },
+          React.createElement("h3", { style: { margin: "0 0 4px" } }, uiText("跨会话消息", "Agent messages")),
+          React.createElement("p", { style: { color: "var(--dsw-alias-label-tertiary)", margin: "0 0 12px", fontSize: "13px" } }, uiText("控制投递卡片是否显示传输细节。messageId 始终保留。", "Control transport details in delivery cards. The messageId is always kept.")),
+          React.createElement("label", { style: { display: "flex", gap: "8px", alignItems: "center" } },
+            React.createElement("input", { type: "checkbox", checked: draft, disabled: !writable, onChange: function (event) { setDraft(event.target.checked); } }),
+            uiText("显示投递模式和目标运行状态", "Show delivery mode and target runtime status")),
+          error ? React.createElement("p", { role: "alert", style: { color: "var(--dsw-alias-state-error)", margin: "10px 0 0", fontSize: "13px" } }, uiText("保存失败，设置可能已被其他页面修改。", "Save failed; the setting may have changed elsewhere.")) : null,
+          React.createElement("div", { style: { display: "flex", gap: "8px", marginTop: "14px" } },
+            React.createElement("button", { type: "button", disabled: !dirty || saving || !writable, onClick: reset }, uiText("恢复默认", "Reset")),
+            React.createElement("button", { type: "button", disabled: !dirty || saving || !writable, onClick: save }, saving ? uiText("保存中…", "Saving…") : uiText("保存", "Save")))
+        );
       }
 
-      function cleanupRoots(node) {
-        mountedRoots.forEach(function (root, host) {
-          if (node === host || (node instanceof Element && node.contains(host))) {
-            root.unmount();
-            mountedRoots.delete(host);
-          }
-        });
-        sessionLinks.forEach(function (element) {
-          if (node === element || (node instanceof Element && node.contains(element))) sessionLinks.delete(element);
+      if (ctx.settingsScope !== undefined && ctx.slots !== undefined) {
+        const scope = ctx.settingsScope.bind({ namespace: AGENT_MESSAGE_SETTINGS_NAMESPACE });
+        const agentMessageSettingsStore = {
+          getSnapshot: function () { return scope.getSnapshot(); },
+          subscribe: function (listener) { return scope.subscribe(listener); },
+        };
+        ctx.slots.inject("settings.plugin.item", function () {
+          return ctx.slots.register({
+            name: "settings.plugin.item",
+            key: AGENT_MESSAGE_SETTINGS_NAMESPACE,
+            inject: function () {
+              return {
+                hooks: { agentMessageSettings: agentMessageSettingsStore },
+                setShowTechnicalDetails: function (value) { return scope.set("showTechnicalDetails", value); },
+              };
+            },
+          }, AgentMessageSettingsCard);
         });
       }
 
-      function SessionActivity(props) {
-        return props.running
-          ? React.createElement(StateDot, { state: "done", size: 10, className: "agent-msg-status-dot" })
-          : React.createElement("span", { className: "agent-msg-status-dot agent-msg-status-dot-idle", "aria-hidden": "true" });
+      function uiText(zh, en) {
+        return getLocaleSnapshot().active === "zh" ? zh : en;
       }
 
-      function SessionReference(props) {
-        return React.createElement("span", { className: "agent-msg-reference-content" },
-          React.createElement(IconQueueOutline14, { size: 14, className: "agent-msg-session-icon" }),
-          React.createElement("span", { className: "agent-msg-reference-title" }, "@" + sessionTitle(props.row)));
+      function sessionRow(id) {
+        return ctx.sessions.list.getSnapshot().byId[id];
       }
 
-      function RelaySender(props) {
-        return React.createElement("span", { className: "agent-msg-relay-sender-content" },
-          React.createElement(IconQueueOutline14, { size: 14, className: "agent-msg-session-icon" }),
-          React.createElement("span", null, "From Session · " + props.title + ":"));
+      function sessionTitle(row) {
+        return String(row?.displayTitle || row?.title || row?.id || "");
       }
 
-      function enhanceReferenceHost(element, row) {
-        let host = element.querySelector(":scope > .agent-msg-reference-host");
-        if (!host) {
-          element.textContent = "";
-          host = document.createElement("span");
-          host.className = "agent-msg-reference-host";
-          element.appendChild(host);
-        }
-        renderInto(host, React.createElement(SessionReference, { row: row }));
+      function cleanupRoots(node) {
+        if (!(node instanceof Element)) return;
+        const links = node.matches(".agent-msg-session-link")
+          ? [node].concat(Array.from(node.querySelectorAll(".agent-msg-session-link")))
+          : Array.from(node.querySelectorAll(".agent-msg-session-link"));
+        links.forEach(function (element) { sessionLinks.delete(element); });
       }
 
-      const inputTriggers = ctx.get("inputTriggers");
-      if (inputTriggers !== undefined) {
-        ctx.effect(() => inputTriggers.registerSource({
-          trigger: "@",
-          name: referenceSource,
-          order: 2,
-          async candidates(session, request) {
-            if (request.position !== "leading") return [];
-            const query = String(request.query || "").toLowerCase();
-            return sessionRows(false)
-              .filter(function (row) {
-                return String(row.id) !== String(session.sessionId)
-                  && (query === "" || sessionTitle(row).toLowerCase().includes(query));
-              })
-              .sort(function (a, b) {
-                if (a.running !== b.running) return a.running ? -1 : 1;
-                return sessionTitle(a).localeCompare(sessionTitle(b));
-              })
-              .map(function (row) {
-                const candidate = {
-                  name: sessionTitle(row),
-                  description: row.running ? uiText("运行中", "Running") : uiText("空闲", "Idle"),
-                  icon: "",
-                };
-                candidateRows.set(candidate, row);
-                return candidate;
-              });
-          },
-          onPick({ candidate, session }) {
-            const row = candidateRows.get(candidate);
-            if (!row) return undefined;
-            const label = "@" + compactSessionTitle(row);
-            return {
-              claim: {
-                token: label + " ",
-                hint: uiText("输入要处理的内容", "Describe what to do"),
-                async submit(args) {
-                  const content = String(args || "").trim();
-                  if (content === "") return { kind: "error", text: uiText("请输入要处理的内容", "Describe what to do") };
-                  const binding = ctx.sessions.binding(session.sessionId);
-                  if (!binding) return { kind: "error", text: uiText("当前会话不可用", "Current session is unavailable") };
-                  const result = await binding.session.prompt([{
-                    type: "text",
-                    text: "@" + String(row.id) + " " + content,
-                  }], "queue");
-                  return result.ok
-                    ? { kind: "success" }
-                    : { kind: "error", text: result.error.message };
-                },
-              },
-            };
-          },
-        }), "dsh-agent-message: @ session source");
+      function restoreSender(element) {
+        if (element.dataset.agentMsgOriginalText !== undefined) {
+          element.textContent = element.dataset.agentMsgOriginalText;
+        }
+        delete element.dataset.agentMsgOriginalText;
+        delete element.dataset.agentMsgSessionId;
+        delete element.dataset.agentMsgSenderTitle;
+        element.classList.remove("agent-msg-session-link", "agent-msg-sender-link");
+        ["role", "tabindex", "title", "aria-label"].forEach(function (name) { element.removeAttribute(name); });
       }
 
       function senderLink(target) {
@@ -164,25 +118,6 @@ window.__ModuleLoader__.load({
         return match ? { element: element, sessionId: match[0] } : null;
       }
 
-      function titleFrom(text) {
-        const line = String(text || "").split("\n", 1)[0].trim();
-        const current = line.match(/^From (?:Session|Agent)(?: ·)? (.+?):(?: @session-[\w-]+)?$/);
-        const previous = line.match(/^来自 Agent · (.+)$/);
-        const legacy = line.match(/^来自 Agent「(.+)」\s*[·：:]?$/);
-        return (current || previous || legacy)?.[1]?.trim() || "";
-      }
-
-      function senderTitle(element) {
-        if (element.dataset.agentMsgSenderTitle) return element.dataset.agentMsgSenderTitle;
-        const label = element.previousElementSibling;
-        const title = titleFrom(label?.textContent);
-        if (title && label) {
-          label.textContent = "";
-          label.classList.add("agent-msg-sender-prefix");
-        }
-        return title;
-      }
-
       function prepareSenderLinks(root) {
         if (!(root instanceof Element)) return;
         const elements = root.matches(senderSelector)
@@ -191,19 +126,19 @@ window.__ModuleLoader__.load({
         elements.forEach(function (element) {
           const link = senderLink(element);
           if (!link) return;
-          const relay = element.matches("[data-context-relay-sender]");
-          const title = relay ? sessionTitle(sessionRow(link.sessionId)) || "@" + link.sessionId : senderTitle(element);
-          if (!relay && !title) return;
+          const title = sessionTitle(sessionRow(link.sessionId)) || "@" + link.sessionId;
+          if (element.dataset.agentMsgOriginalText === undefined) {
+            element.dataset.agentMsgOriginalText = element.textContent || "";
+          }
           element.dataset.agentMsgSessionId = link.sessionId;
-          if (title) element.dataset.agentMsgSenderTitle = title;
-          if (relay) renderInto(element, React.createElement(RelaySender, { title: title }));
-          else element.textContent = "From Session · " + title + ":";
+          element.dataset.agentMsgSenderTitle = title;
+          element.textContent = uiText("来自会话 · ", "From Session · ") + title + ":";
           element.classList.add("agent-msg-session-link", "agent-msg-sender-link");
           sessionLinks.add(element);
           element.setAttribute("role", "link");
           element.setAttribute("tabindex", "0");
-          element.setAttribute("title", "打开发送方会话");
-          element.setAttribute("aria-label", "打开发送方会话：" + (title || link.sessionId));
+          element.setAttribute("title", uiText("打开发送方会话", "Open sender session"));
+          element.setAttribute("aria-label", uiText("打开发送方会话：", "Open sender session: ") + (title || link.sessionId));
         });
       }
 
@@ -234,74 +169,18 @@ window.__ModuleLoader__.load({
         });
       }
 
-      function prepareSessionReferences(root) {
-        if (!(root instanceof Element)) return;
-        const elements = root.matches('[data-ref-chip="subagent"]')
-          ? [root].concat(Array.from(root.querySelectorAll('[data-ref-chip="subagent"]')))
-          : Array.from(root.querySelectorAll('[data-ref-chip="subagent"]'));
-        elements.forEach(function (element) {
-          if (element.classList.contains("agent-msg-sender-link")) return;
-          const id = element.dataset.agentMsgSessionId
-            || String(element.textContent || "").trim().match(/^@(session-[\w-]+)$/)?.[1];
-          const row = id ? sessionRow(id) : undefined;
-          if (!id || !row) return;
-          element.dataset.agentMsgSessionId = id;
-          element.classList.add("agent-msg-session-link", "agent-msg-reference-link");
-          sessionLinks.add(element);
-          element.setAttribute("role", "link");
-          element.setAttribute("tabindex", "0");
-          element.setAttribute("title", uiText("打开引用会话", "Open referenced session"));
-          element.setAttribute("aria-label", uiText("打开引用会话：", "Open referenced session: ") + sessionTitle(row));
-          enhanceReferenceHost(element, row);
-        });
-      }
-
-      function prepareSessionMenu(root) {
-        if (!(root instanceof Element)) return;
-        const menu = root.matches('[role="listbox"]') ? root : root.closest('[role="listbox"]') || root.querySelector('[role="listbox"]');
-        if (!menu) return;
-        const group = menu.querySelector('[data-source="' + referenceSource + '"]');
-        if (!group) return;
-        group.textContent = uiText("会话", "Sessions");
-        let element = group.nextElementSibling;
-        while (element && !element.hasAttribute("data-source")) {
-          if (element.matches('button[role="option"]')) {
-            element.classList.add("agent-msg-session-candidate");
-            const spans = element.querySelectorAll(":scope > span");
-            const icon = spans[0];
-            const description = spans[2];
-            if (icon) {
-              icon.classList.add("agent-msg-candidate-icon");
-              renderInto(icon, React.createElement(IconQueueOutline14, { size: 14 }));
-            }
-            if (description) {
-              const running = /^(运行中|Running)$/.test(String(description.textContent || "").trim())
-                || element.dataset.agentMsgRunning === "true";
-              element.dataset.agentMsgRunning = String(running);
-              renderInto(description, React.createElement("span", { className: "agent-msg-status-label" },
-                React.createElement(SessionActivity, { running: running }),
-                React.createElement("span", null, running ? uiText("运行中", "Running") : uiText("空闲", "Idle"))));
-            }
-          }
-          element = element.nextElementSibling;
-        }
-      }
-
       function prepare(root) {
         prepareRelayCards(root);
         prepareSenderLinks(root);
-        prepareSessionReferences(root);
-        prepareSessionMenu(root);
       }
 
-      function refreshSessionLinks() {
+      function refreshSenderLinks() {
         sessionLinks.forEach(function (element) {
           if (!element.isConnected) {
             sessionLinks.delete(element);
             return;
           }
-          if (element.classList.contains("agent-msg-sender-link")) prepareSenderLinks(element);
-          else prepareSessionReferences(element);
+          prepareSenderLinks(element);
         });
       }
 
@@ -351,6 +230,7 @@ window.__ModuleLoader__.load({
       }
 
       function CopyButton(props) {
+        useLocale();
         const [copyState, setCopyState] = React.useState("idle");
         async function onClick() {
           const text = String(props.sessionId || "");
@@ -363,39 +243,29 @@ window.__ModuleLoader__.load({
           type: "button",
           onClick: onClick,
           onMouseLeave: onMouseLeave,
-          title: "复制会话 ID",
-          "aria-label": "复制会话 ID",
+          title: uiText("复制会话 ID", "Copy session ID"),
+          "aria-label": uiText("复制会话 ID", "Copy session ID"),
           className: "agent-msg-copy-id"
-        }, copyState === "copied" ? "已复制" : copyState === "failed" ? "复制失败" : "复制ID");
+        }, copyState === "copied"
+          ? uiText("已复制", "Copied")
+          : copyState === "failed"
+            ? uiText("复制失败", "Copy failed")
+            : uiText("复制ID", "Copy ID"));
       }
 
       ctx.slots.inject("conversation.session.header.actions", () => ctx.slots.register(
-        { name: "conversation.session.header.actions", id: "copy-session-id", order: 30, label: "复制会话ID" },
+        { name: "conversation.session.header.actions", id: "copy-session-id", order: 30, label: uiText("复制会话ID", "Copy session ID") },
         (props) => React.createElement(CopyButton, { sessionId: props.sessionId })
       ));
 
       const css =
         ".agent-msg-copy-id { cursor: pointer; font-size: 12px; line-height: 1; padding: 5px 10px; border: 1px solid rgba(127,127,127,.35); border-radius: 6px; background: transparent; color: inherit; opacity: .85; } " +
         ".agent-msg-copy-id:hover { opacity: 1; border-color: rgba(127,127,127,.7); } " +
-        ".agent-msg-sender-prefix { display: none !important; } " +
         ".agent-msg-session-link { cursor: pointer; text-decoration: none; } " +
-        ".agent-msg-sender-link[data-ref-chip=\"subagent\"] { display: block; width: fit-content; padding: 0; background: transparent; color: inherit; font-size: 13px; font-weight: 600; line-height: 1.5; } " +
-        ".agent-msg-reference-link { display: inline-flex !important; align-items: center; color: var(--dsw-alias-state-business-primary) !important; } " +
-        ".agent-msg-reference-host, .agent-msg-reference-content { display: inline-flex; min-width: 0; align-items: center; } " +
-        ".agent-msg-reference-content { gap: 5px; max-width: 100%; } " +
-        ".agent-msg-reference-title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } " +
-        ".agent-msg-session-icon, .agent-msg-candidate-icon { display: inline-flex; flex: none; color: var(--dsw-alias-state-business-primary); } " +
-        ".agent-msg-relay-sender-content { display: inline-flex; align-items: center; gap: 5px; } " +
         "[data-agent-msg-relay-card] [data-disclosure-row] { display: none !important; } " +
         "[data-agent-msg-relay-card] [data-context-form=\"relay\"] { width: fit-content; max-width: min(78%, 760px); max-height: none; margin: 0; padding: 14px 16px; overflow: visible; border: 1px solid rgba(127,127,127,.24); border-radius: 16px 16px 16px 4px; background: var(--dsw-alias-markdown-code-block); color: var(--dsw-alias-label-primary); font: inherit; } " +
         "[data-agent-msg-relay-card] [data-context-relay-sender] { display: block; width: fit-content; margin: 0 0 8px; color: var(--dsw-alias-state-business-primary); font-size: 13px; font-weight: 600; line-height: 1.5; } " +
         "[data-agent-msg-relay-card] [data-context-text] { margin: 0; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere; color: inherit; font: inherit; } " +
-        ".agent-msg-status-dot { flex: none; } " +
-        ".agent-msg-status-dot-idle { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: var(--dsw-alias-label-tertiary); opacity: .7; } " +
-        ".agent-msg-status-label { display: inline-flex; align-items: center; gap: 6px; } " +
-        ".agent-msg-session-candidate { border-radius: 0 !important; } " +
-        ".agent-msg-session-candidate > span:nth-child(2) { flex: 1; min-width: 0; max-width: none; } " +
-        ".agent-msg-session-candidate > span:nth-child(3) { display: flex; flex: none; justify-content: flex-end; margin-left: auto; } " +
         ".agent-msg-session-link:hover { text-decoration: underline; text-underline-offset: 3px; } " +
         ".agent-msg-session-link:focus-visible { outline: 2px solid currentColor; outline-offset: 3px; border-radius: 2px; }";
       const tag = document.createElement("style");
@@ -410,18 +280,17 @@ window.__ModuleLoader__.load({
         });
       });
       observer.observe(document.body, { childList: true, subtree: true });
-      const unsubscribeSessions = ctx.sessions.list.subscribe(refreshSessionLinks);
-      const unsubscribeWorkspaces = workspaces?.list.subscribe(refreshSessionLinks);
+      const unsubscribeSessions = ctx.sessions.list.subscribe(refreshSenderLinks);
+      const unsubscribeLocale = ctx.locale.subscribe(refreshSenderLinks);
       document.addEventListener("click", openSender);
       document.addEventListener("keydown", onKeyDown);
       ctx.effect(() => () => {
         observer.disconnect();
         unsubscribeSessions();
-        unsubscribeWorkspaces?.();
+        unsubscribeLocale();
         document.removeEventListener("click", openSender);
         document.removeEventListener("keydown", onKeyDown);
-        mountedRoots.forEach(function (root) { root.unmount(); });
-        mountedRoots.clear();
+        sessionLinks.forEach(restoreSender);
         sessionLinks.clear();
         tag.remove();
       });

package/lib/index.js

@@ -1,18 +1,39 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { createUserMessage, freezeMessage } from '@deepseek-ai/dsh-llm/message'
+import z from '@deepseek-ai/schemastery'
+import { installSettingsSection, settingsNamespace } from '@deepseek-ai/dsh-settings'
 
 export const name = 'dsh-agent-message'
 export const inject = ['agents', 'tools', 'sessionQuery']
 
+const AGENT_MESSAGE_SETTINGS_NAMESPACE = settingsNamespace('agent-message')
+const AGENT_MESSAGE_SETTINGS_SCHEMA = z.object({ showTechnicalDetails: z.boolean().default(true) })
+
 export function apply(ctx) {
   const agents = ctx.agents
+  let settingsSource = () => ({ showTechnicalDetails: true })
   /** messageId -> { to, at, mode }；发送成功即记账，供批量查询及补充本进程发送信息。 */
   const sent = new Map()
   /** 记账表 FIFO 上限：超过则淘汰最老记录，内存恒定。 */
   const SENT_MAX = 1000
+  const PAIR_MESSAGE_LIMIT = 10
+  const PAIR_WINDOW_MS = 60_000
   const receiptMeaning = 'claimed 仅表示目标 turn 已从 Inbox 认领消息；传输回执不表示对方已读、回复或完成。'
   /** 插件恢复的 Session handle；保留到插件卸载，避免 idle dispose 移除 Harness store 投影。 */
   const resumedHandles = new Map()
+  /** 无向 Session 对 -> 最近成功或正在进行的投递预留；只保护当前 Harness 进程。 */
+  const pairSends = new Map()
+  let lastPairPruneAt = 0
+
+  // 设置由 Cordis 注入；旧版测试宿主没有 inject 时继续使用默认行为。
+  if (typeof ctx.inject === 'function') {
+    installSettingsSection(ctx, AGENT_MESSAGE_SETTINGS_NAMESPACE, AGENT_MESSAGE_SETTINGS_SCHEMA, { showTechnicalDetails: true }, {
+      setSource(source) {
+        settingsSource = source
+      },
+      onChange() {},
+    })
+  }
 
   ctx.effect(() => async () => {
     const handles = [...resumedHandles.values()]
@@ -37,6 +58,35 @@ export function apply(ctx) {
     if (sent.size > SENT_MAX) sent.delete(sent.keys().next().value)
   }
 
+  function reservePairSend(from, to) {
+    const now = Date.now()
+    if (now < lastPairPruneAt || now - lastPairPruneAt >= PAIR_WINDOW_MS) {
+      for (const [key, entries] of pairSends) {
+        const active = entries.filter((entry) => now - entry.at < PAIR_WINDOW_MS)
+        if (active.length === 0) pairSends.delete(key)
+        else pairSends.set(key, active)
+      }
+      lastPairPruneAt = now
+    }
+    const key = JSON.stringify([String(from), String(to)].sort())
+    const recent = (pairSends.get(key) ?? []).filter((entry) => now - entry.at < PAIR_WINDOW_MS)
+    if (recent.length >= PAIR_MESSAGE_LIMIT) {
+      pairSends.set(key, recent)
+      const retryAfterSeconds = Math.max(1, Math.ceil((PAIR_WINDOW_MS - (now - recent[0].at)) / 1000))
+      throw new Error('同一对会话 60 秒内最多投递 10 条消息；请勿立即重试，约 ' + retryAfterSeconds + ' 秒后窗口重置')
+    }
+    const reservation = { at: now }
+    recent.push(reservation)
+    pairSends.set(key, recent)
+    return () => {
+      const current = pairSends.get(key)
+      if (current === undefined) return
+      const index = current.indexOf(reservation)
+      if (index !== -1) current.splice(index, 1)
+      if (current.length === 0) pairSends.delete(key)
+    }
+  }
+
   function titleOf(agent) {
     const service = ctx.get('sessionTitle')
     if (service !== undefined) {
@@ -71,6 +121,12 @@ export function apply(ctx) {
     return header?.origin === 'subagent'
   }
 
+  function assertPeerCaller(agent) {
+    if (agent !== undefined && isSubagentSession(agent.session.header)) {
+      throw new Error('子代理不能使用独立会话通信工具')
+    }
+  }
+
   function sessionQuery() {
     const query = ctx.get('sessionQuery')
     if (query === undefined) throw new Error('本部署缺少 sessionQuery，无法查询逻辑会话')
@@ -180,6 +236,7 @@ export function apply(ctx) {
     },
     async execute(_args, exec) {
       const me = exec.agent
+      assertPeerCaller(me)
       const archived = archivedIds()
       const query = sessionQuery()
       const live = new Map()
@@ -230,6 +287,7 @@ export function apply(ctx) {
       '默认使用 followup 创建独立的新 turn；' +
       '目标离线（进程里未加载）时自动恢复该会话后投递。' +
       '用户无需说出模式名：目标为 running 且整句明确要求立即介入时用 steer，明确要求不打断当前任务、只补充上下文时用 inject；不确定时使用 followup。' +
+      '同一对 Session 双向合计 60 秒内最多投递 10 条消息，超过时拒绝本次投递。' +
       '归档会话和子代理一律拒绝。' +
       '注意：它不同于 send_message（后者是给你的后台子代理续聊）。',
     parameters: {
@@ -240,14 +298,36 @@ export function apply(ctx) {
     output: {
       schema: { type: 'json' },
       render(_args, value) {
-        return [{ type: 'text', text: value.text || JSON.stringify(value) }]
+        return [{ type: 'text', text: '已投递。\nmessageId: ' + value.messageId }]
+      },
+      presentationMeta(_args, value) {
+        return value
       },
     },
+    presentResult(_args, result) {
+      const meta = result.meta
+      if (result.isError || meta === null || typeof meta !== 'object' || Array.isArray(meta)) return
+      const messageId = typeof meta.messageId === 'string' ? meta.messageId : ''
+      const text = (typeof meta.text === 'string' ? meta.text : '已投递。')
+        + (messageId ? '\nmessageId: ' + messageId : '')
+        const details = settingsSource().showTechnicalDetails
+        ? '\n' + JSON.stringify({ to: meta.to, mode: meta.mode, state: meta.state, targetRuntimeStatus: meta.targetRuntimeStatus })
+        : ''
+      return {
+        card: 'generic',
+        title: '消息已投递',
+        content: [{ type: 'text', text: text + details }],
+      }
+    },
     async execute(args, exec) {
       const me = exec.agent
       if (me === undefined) throw new Error('no calling agent')
+      assertPeerCaller(me)
       const to = args.to
       if (to === '' || String(to) === String(me.id)) throw new Error('不能给自己发消息')
+      if (args.content.includes('<dsh-agent-message>') || args.content.includes('</dsh-agent-message>')) {
+        throw new Error('消息正文不能包含保留协议标签 dsh-agent-message')
+      }
 
       const archived = archivedIds()
       if (archived.has(String(to))) throw new Error('对方会话已归档，无法发送（请先取消归档）')
@@ -260,6 +340,14 @@ export function apply(ctx) {
         throw new Error(mode + ' 仅用于 running 会话；目标当前状态：' + target.status)
       }
 
+      let inspected
+      if (target === undefined) {
+        inspected = await readLogicalSession(to)
+        if (inspected === undefined) throw new Error('会话不存在：' + to)
+        if (isSubagentSession(inspected.session)) throw new Error('目标是子代理，不能通过会话通信插件直接发送')
+        if (mode !== 'followup') throw new Error('目标离线（进程里未加载）：' + mode + ' 仅用于 running 会话')
+      }
+
       const myTitle = titleOf(me) || String(me.id)
       const source = {
         kind: name,
@@ -279,19 +367,21 @@ export function apply(ctx) {
       let usedMode = ''
       let targetRuntimeStatus = 'offline'
 
-      if (target !== undefined) {
-        if (mode === 'followup') { target.followup(message); usedMode = mode }
-        else if (mode === 'inject') { target.inject(message); usedMode = 'inject' }
-        else { target.steer(message); usedMode = 'steer' }
-        targetRuntimeStatus = target.status
-      } else {
-        const inspected = await readLogicalSession(to)
-        if (inspected === undefined) throw new Error('会话不存在：' + to)
-        if (isSubagentSession(inspected.session)) throw new Error('目标是子代理，不能通过会话通信插件直接发送')
-        if (mode !== 'followup') throw new Error('目标离线（进程里未加载）：' + mode + ' 仅用于 running 会话')
-        const resumed = await resumeAndFollowup(to, message, inspected)
-        usedMode = 'followup'
-        targetRuntimeStatus = resumed.status
+      const rollbackPairSend = reservePairSend(me.id, to)
+      try {
+        if (target !== undefined) {
+          if (mode === 'followup') { target.followup(message); usedMode = mode }
+          else if (mode === 'inject') { target.inject(message); usedMode = 'inject' }
+          else { target.steer(message); usedMode = 'steer' }
+          targetRuntimeStatus = target.status
+        } else {
+          const resumed = await resumeAndFollowup(to, message, inspected)
+          usedMode = 'followup'
+          targetRuntimeStatus = resumed.status
+        }
+      } catch (error) {
+        rollbackPairSend()
+        throw error
       }
 
       rememberSent(message.id, String(to), usedMode)
@@ -324,7 +414,8 @@ export function apply(ctx) {
         return [{ type: 'text', text: JSON.stringify(value, null, 2) }]
       },
     },
-    async execute(args) {
+    async execute(args, exec) {
+      assertPeerCaller(exec?.agent)
       const target = agents.get(args.to)
       const targetRuntimeStatus = target !== undefined ? target.status : 'offline'
       if (args.messageId !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-agent-message",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "packageManager": "pnpm@11.1.1",
   "description": "跨会话 Agent 通信：让 DeepSeek Harness 里不同的 Agent 会话互相收发消息。",
   "keywords": ["deepseek", "deepseek-harness", "agent", "multi-agent", "messaging"],
@@ -12,7 +12,10 @@
   },
   "type": "module",
   "main": "./lib/index.js",
-  "scripts": { "test": "node --test" },
+  "scripts": {
+    "test": "node --test",
+    "test:web-smoke": "node scripts/web-smoke.mjs"
+  },
   "exports": {
     ".": { "default": "./lib/index.js" },
     "./client": { "default": "./lib/client.js" },
@@ -26,10 +29,11 @@
       "platform": "web",
       "inject": [
         "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-slots",
-        "@deepseek-ai/dsh-client-ui-conversation",
-        "@deepseek-ai/dsh-client-ui-input-trigger",
-        "@deepseek-ai/dsh-client-ui-primitives"
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-plugins",
+        "@deepseek-ai/dsh-client-ui-conversation"
       ]
     }
   },
@@ -41,16 +45,20 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.6 <0.2.0",
-    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.6 <0.2.0"
+    "@deepseek-ai/dsh-settings": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-llm": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-tools": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/schemastery": ">=3.18.1 <4.0.0"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "0.1.0-rc.6"
+    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
+    "@deepseek-ai/schemastery": "3.18.1"
   },
   "engines": {
     "node": ">=24 <25",
-    "dsh": ">=0.1.0-rc.6 <0.2.0"
+    "dsh": ">=0.1.1-rc.2 <0.2.0"
   },
   "license": "MIT"
 }