dsh-agent-message 1.5.1 → 1.6.0

package/README.en.md

@@ -25,9 +25,10 @@ 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
 
@@ -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,8 +78,8 @@ 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` only when the current request or an orchestration responsibility already granted by the user requires cross-session communication. For example, `@B tell it to stop after opening the draft PR` sends, while `@B analyze its latest conversation result` must not send a message to B;
+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;
@@ -99,13 +100,13 @@ 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`; the model receives only a terse “delivered” projection while the complete result 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.
+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.
 
 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.
 
@@ -115,14 +116,25 @@ See [`docs/architecture-v2.md`](./docs/architecture-v2.md) for the current archi
 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/               # current architecture 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
 ```
 
+## Development validation
+
+```sh
+pnpm test
+pnpm run test:web-smoke
+pnpm peers check
+```
+
+`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.

package/README.md

@@ -25,9 +25,10 @@
 | `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` 始终显示 |
 
 ### 发送方导航示例
 
@@ -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,8 +79,8 @@ Agent 会用 bash 执行这条命令，装完自动挂载、所有会话立即
 
 ## 使用
 
-1. 在会话 A 的输入框开头键入 `@`，从原生候选菜单中选择目标会话；候选会显示标题和“运行中/空闲”；
-2. `@` 只告诉 A 信息或操作的目标在哪里，不代表发送。当前请求或用户已授予的编排职责要求跨会话传递信息时，A 才调用 `send_agent_message`。例如 `@B 告诉他最后提交 PR draft 就停止` 会发送，`@B 帮我分析他最新的对话结果` 则不应向 B 发消息；
+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 消息卡片，并可从消息头打开发送方会话；
@@ -100,13 +101,13 @@ 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 或单纯的“收到”。插件不自动关联请求与回复，也不自动转发 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)。
 
@@ -116,14 +117,25 @@ relay 只表达“另一会话发来的消息”，本身不等于必须回复
 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
+```
+
+`test:web-smoke` 需要本机已安装 `dsh` 并配置 Web Profile，它只验证启动、插件组合和 HTTP 可达性；真实交互验收记录见 [`docs/architecture-v2.md`](./docs/architecture-v2.md#14-验证记录)。
+
 ## 限制
 
 - 目标会话必须**未归档**且存在于本机持久化里；归档会话一律拒绝发送。

package/lib/client.js

@@ -5,159 +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 reactRootSelector = "[data-agent-msg-react-root]";
-      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;
+      const AGENT_MESSAGE_SETTINGS_NAMESPACE = "agent-message";
+
+      function useLocale() {
+        React.useSyncExternalStore(subscribeLocale, getLocaleSnapshot);
       }
 
-      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 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);
+        }
+        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 sessionRow(id) {
-        return ctx.sessions.list.getSnapshot().byId[id];
+      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 sessionTitle(row) {
-        return String(row?.displayTitle || row?.title || row?.id || "");
+      function uiText(zh, en) {
+        return getLocaleSnapshot().active === "zh" ? zh : en;
       }
 
-      function compactSessionTitle(row) {
-        const chars = Array.from(sessionTitle(row));
-        return chars.length > 40 ? chars.slice(0, 39).join("") + "…" : chars.join("");
+      function sessionRow(id) {
+        return ctx.sessions.list.getSnapshot().byId[id];
       }
 
-      function renderInto(host, content) {
-        let root = mountedRoots.get(host);
-        if (!root) {
-          root = createRoot(host);
-          mountedRoots.set(host, root);
-          host.setAttribute("data-agent-msg-react-root", "true");
-        }
-        root.render(content);
+      function sessionTitle(row) {
+        return String(row?.displayTitle || row?.title || row?.id || "");
       }
 
       function cleanupRoots(node) {
         if (!(node instanceof Element)) return;
-        const hosts = node.matches(reactRootSelector)
-          ? [node].concat(Array.from(node.querySelectorAll(reactRootSelector)))
-          : Array.from(node.querySelectorAll(reactRootSelector));
-        hosts.forEach(function (host) {
-          const root = mountedRoots.get(host);
-          if (!root) return;
-          root.unmount();
-          mountedRoots.delete(host);
-        });
         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); });
       }
 
-      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 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 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, uiText("来自会话 · ", "From Session · ") + props.title + ":"));
-      }
-
-      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);
+      function restoreSender(element) {
+        if (element.dataset.agentMsgOriginalText !== undefined) {
+          element.textContent = element.dataset.agentMsgOriginalText;
         }
-        renderInto(host, React.createElement(SessionReference, { row: row }));
-      }
-
-      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");
+        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) {
@@ -171,24 +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.classList.add("agent-msg-sender-prefix");
-        }
-        return title;
-      }
-
       function prepareSenderLinks(root) {
         if (!(root instanceof Element)) return;
         const elements = root.matches(senderSelector)
@@ -197,13 +126,13 @@ 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 = uiText("来自会话 · ", "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");
@@ -240,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);
         });
       }
 
@@ -357,6 +230,7 @@ window.__ModuleLoader__.load({
       }
 
       function CopyButton(props) {
+        useLocale();
         const [copyState, setCopyState] = React.useState("idle");
         async function onClick() {
           const text = String(props.sessionId || "");
@@ -387,25 +261,11 @@ window.__ModuleLoader__.load({
       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");
@@ -420,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,11 +1,17 @@
 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 上限：超过则淘汰最老记录，内存恒定。 */
@@ -19,6 +25,16 @@ export function apply(ctx) {
   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()]
     resumedHandles.clear()
@@ -56,7 +72,8 @@ export function apply(ctx) {
     const recent = (pairSends.get(key) ?? []).filter((entry) => now - entry.at < PAIR_WINDOW_MS)
     if (recent.length >= PAIR_MESSAGE_LIMIT) {
       pairSends.set(key, recent)
-      throw new Error('同一对会话 60 秒内最多投递 10 条消息，请稍后再试')
+      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)
@@ -280,8 +297,8 @@ export function apply(ctx) {
     },
     output: {
       schema: { type: 'json' },
-      render() {
-        return [{ type: 'text', text: '已投递。' }]
+      render(_args, value) {
+        return [{ type: 'text', text: '已投递。\nmessageId: ' + value.messageId }]
       },
       presentationMeta(_args, value) {
         return value
@@ -290,10 +307,16 @@ export function apply(ctx) {
     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: meta.text || JSON.stringify(meta, null, 2) }],
+        content: [{ type: 'text', text: text + details }],
       }
     },
     async execute(args, exec) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-agent-message",
-  "version": "1.5.1",
+  "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"
 }