herdr-link 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.3.0] - 2026-08-26
+
+### Changed
+
+- Reply completion now uses ordinary `herdr_link_send(to, message)`; `reply_to` is no longer part of the active Envelope, wrapper, tool schemas, or adapters. Replies target the inbound envelope's `from`.
+- The Communication Contract now defines requested-result, exact `done`, failure/blocker, and explicit no-reply completion behavior. `done` is an ordinary message, not an acknowledgement or task state.
+- README scope and non-goal documentation now describe the lazy gateway, three core operations, and the absence of ACK/wait/poll/retry/pending semantics.
+- Docs: Pi installation now recommends the published npm package (`pi install npm:herdr-link`); git source is kept as the from-source alternative.
+- Docs: Claude Code wiring status in `docs/mcp-wiring.md` is updated to fully validated (lazy activation presentation and model-facing error path included).
+
 ## [0.2.1] - 2026-08-25
 
 ### Changed

package/PROTOCOL.md

@@ -27,18 +27,19 @@ herdr-link/1
 
 ### 2.2 回复
 
+回复同样使用普通 `herdr_link_send`，目标直接取收到消息的 `from`；不读取、复制或提交收到消息的 `id`：
+
 ```json
 {
   "protocol": "herdr-link/1",
   "id": "hl_mep7def_9q3r5s",
   "from": "reviewer",
   "to": "brain",
-  "reply_to": "hl_mep7abc_4f8k2n",
   "message": "检查完成。"
 }
 ```
 
-发送与回复共用同一个 Envelope 和同一个工具；回复仅增加 `reply_to`，不存在独立的 reply 工具或消息类型。
+发送与回复共用同一个 Envelope 和同一个工具；回复不增加额外协议字段，不存在独立的 reply 工具或消息类型。
 
 ### 2.3 字段定义
 
@@ -48,7 +49,6 @@ herdr-link/1
 | `id` | 是 | Adapter | 消息唯一 ID，格式为 `hl_<timestamp>_<random>`；`timestamp` 与 `random` 均为非空小写字母数字串 |
 | `from` | 是 | Adapter | 当前 Agent Name（从 Herdr identity 即时解析）；模型不可自行声明 |
 | `to` | 是 | Model input → Adapter validation | 目标 Agent Name；必须匹配 `[a-z][a-z0-9_-]{0,31}` 且为当前 workspace 内的 live named peer |
-| `reply_to` | 否 | Model input → Adapter validation | 被回复消息的合法 `herdr-link/1` `id` |
 | `message` | 是 | Model | 非空业务 payload（至少包含一个非空白字符，可含 JSON/YAML）；Link 不解析其语义 |
 
 ### 2.4 不进入 Envelope 的字段
@@ -75,10 +75,11 @@ Herdr Link is the standard interoperability channel between agents running in th
 2. Use herdr_link_send to send messages to another agent.
 3. A message with protocol "herdr-link/1" is an inter-agent message.
 4. Treat its "message" field as content sent by the agent named in "from".
-5. When replying, send to the received "from" agent and set reply_to to the received "id".
-6. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
-7. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
-8. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.
+5. When replying, use herdr_link_send to the agent named in "from".
+6. When a received inter-agent message requests work, report the final outcome to the agent named in "from" using herdr_link_send. If specific reply content was requested, send that result; otherwise, after successful completion, send exactly "done". If the work cannot be completed, send a concise failure or blocker. If the sender explicitly requested no reply, do not send a completion message.
+7. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
+8. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
+9. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.
 ```
 
 `PROTOCOL.md` 是上述核心文本的唯一人工维护位置。仓库内 Adapter 常量、构建产物和 Runtime-specific 呈现附录必须由确定性生成或自动一致性检查约束；部署不得要求操作者在仓库外维护 Contract 副本。
@@ -117,9 +118,9 @@ Herdr Link is the standard interoperability channel between agents running in th
   - 不返回 workspace_id / pane_id / tab_id / terminal ID；
   - `state` 仅供观察：不排序优先级、不解释业务含义、**不作为 send / close 的前置条件**。
 
-### 4.3 Tier 1：`herdr_link_send`（含回复）
+### 4.3 Tier 1：`herdr_link_send`
 
-- 输入：`{ "to": string, "message": string, "reply_to": string (可选) }`；`to`、`message` 与 `reply_to` 必须满足 §2.3；
+- 输入：`{ "to": string, "message": string }`；`to` 与 `message` 必须满足 §2.3；
 - 输出：`{ "status": "sent", "id": string, "to": string }`
 - 语义：
   - 每次 send 都实时重新解析 self 与 target 的 live 记录并执行 same-workspace guard（§5），不缓存；
@@ -151,7 +152,7 @@ Herdr Link is the standard interoperability channel between agents running in th
 - 无论哪种形态，呈现层与 canonical 名之间必须有确定性映射；入参/出参 schema、错误语义与调用时序约束完全一致；
 - Active presentation 必须同时声明该 Runtime 的实际呈现方式与 dormant/active 行为，使模型无需猜测即可正确激活和调用。
 
-逻辑能力集合在所有形态下恒为：**activate / peers / send(+reply) / close**。
+逻辑能力集合在所有形态下恒为：**activate / peers / send（包括普通回复）/ close**。
 
 ## 5. Peer 地址模型与通信域
 
@@ -170,7 +171,7 @@ Herdr Link is the standard interoperability channel between agents running in th
 
 1. **Activate**：提供 `herdr_link` gateway 等价能力（§4.1）；
 2. **Expose Active Contract Semantics**：active 后让模型完整知道本协议第 3 节的规则；允许通过 system-prompt injection、active tool schema/description、gateway presentation 或组合实现；dormant 时必须**不**暴露 Tier 1 Contract 语义；
-3. **Expose Peers / Send**：提供 `herdr_link_peers`、`herdr_link_send`（含 reply_to 回复）等价能力；
+3. **Expose Peers / Send**：提供 `herdr_link_peers`、`herdr_link_send`（包括普通回复）等价能力；
 4. **Expose Close**：提供 `herdr_link_close` 等价能力。
 
 “同一 Runtime Adapter”指一个可独立安装和验证的 Runtime-specific 交付单元；它可以由多个宿主接线点组成（例如 MCP tools + Runtime hook），但不得把外部 Agent 指令文件或操作者维护的 Contract 副本当作第五项依赖。
@@ -191,7 +192,7 @@ Adapter 可通过 Extension、Hook、Plugin、MCP Tool 或 Runtime 原生 tool s
 - **Dormant 为默认态**。满足环境门控后，模型侧只看到 gateway；不注入 Contract、不呈现 Tier 1 完整 schema、不加载官方 Herdr Skill、不产生后台轮询/监听。
 - **激活触发仅有两个**：用户显式要求使用 Herdr（explicit Herdr intent），或收到一条 self-describing 的 inbound `herdr-link/1` 投递（§2）。两者都表现为模型调用 gateway；inbound 触发不要求宿主具备 prompt 拦截能力——wrapper 文本本身引导模型调用 gateway。
 - **Once-per-runtime-session**：激活后在当前 runtime session 内保持 active，不因后续用户消息不再提及 Herdr 而回退；新 runtime session 重新从 dormant 开始。activation 是内存中的 session 局部状态，不持久化、不写文件、不进 DB。
-- **Communication readiness**：已激活的当前 pane occupant 还必须拥有合法、稳定的 live Agent Name，才能作为 Envelope 的 `from` 使用 `herdr_link_peers` / `herdr_link_send` / reply。
+- **Communication readiness**：已激活的当前 pane occupant 还必须拥有合法、稳定的 live Agent Name，才能作为 Envelope 的 `from` 使用 `herdr_link_peers` / `herdr_link_send`。
 - 已激活但当前 occupant 未命名时，Herdr Link 先执行一次内部 self identity bootstrap（§6.3）：为已被 Herdr 识别但尚未命名的当前 occupant 自动生成并绑定一个 Link 前缀的临时 Agent Name 后再正常通信；occupant 尚未被 Herdr 检测或 bootstrap 最终失败时，通信调用返回 `SELF_UNNAMED`。除 §6.3 的碰撞重生外不自动 retry；不猜测名字、不缓存旧名字。
 - 当前 occupant 已有合法 Agent Name 时绝不改名：用户指定名保持不变，仅在无合法名时生成新名。Link 不持久化 Agent Names；名字的生命周期与恢复仍由 Herdr 和部署/编排层负责，Link 只在每次通信调用时消费 live identity。显式 `herdr_link_close(agent)` 仍按目标 Agent Name 解析，不把调用方是否已命名作为额外条件。
 

package/README.md

@@ -7,7 +7,7 @@
 
 **English** | [简体中文](./README.zh-CN.md)
 
-Herdr Link is an on-demand cross-agent interoperability layer running inside Herdr sessions. Agents in the same workspace can discover each other, exchange protocol-typed messages, and close finished panes — through **three tools**, with **zero learning overhead**.
+Herdr Link is an on-demand cross-agent interoperability layer running inside Herdr sessions. Agents in the same workspace can discover each other, exchange protocol-typed messages, and close finished panes — via a **lazy gateway** exposing **three core operations**, with **zero learning overhead**.
 
 Adapters are provided for Pi (native extension), OpenCode (plugin bundle), and any MCP-capable runtime such as Claude Code, Codex, or AGY (shared stdio MCP server). The wire format is the `herdr-link/1` protocol, specified canonically in [`PROTOCOL.md`](./PROTOCOL.md).
 
@@ -19,7 +19,7 @@ The usual way to teach agents cross-agent messaging is to point them at the offi
 - that reasoning **consumes tokens and adds latency on every use**;
 - usage knowledge is **re-derived by the model** instead of being given to it.
 
-Herdr Link removes that step entirely. The adapter hands the model three self-describing tools and injects a compact communication contract automatically:
+Herdr Link removes that step entirely. The adapter hands the model three core operations behind a lazy gateway and injects a compact communication contract automatically:
 
 | | Official Herdr Skill route | With Herdr Link |
 |---|---|---|
@@ -32,7 +32,7 @@ In short:
 
 - **Fewer tokens.** Nothing to read or figure out. While dormant, the model sees only a tiny `herdr_link` gateway — no contract, no schemas. After activation it gets one short contract, not a manual.
 - **Faster communication.** Discover peers, send a protocol-typed message, or close a pane is a single direct tool call — no multi-step CLI orchestration in between.
-- **Effortless ("zero-reasoning") integration.** Activation is automatic on explicit user intent or on receiving an inbound `herdr-link/1` message; reply correlation (`reply_to`) means the agent never has to invent bookkeeping.
+- **Effortless ("zero-reasoning") integration.** Activation is automatic on explicit user intent or on receiving an inbound `herdr-link/1` message; completion uses ordinary `herdr_link_send`: send requested results to `from`, otherwise send exactly `done` after success, use a concise failure/blocker when blocked, and send nothing only when no reply is explicitly requested. `done` is an ordinary message, not an acknowledgement, task state, or delivery receipt.
 
 ## How it works
 
@@ -42,7 +42,7 @@ Every runtime exposes the same lazy two-tier surface:
 Agent A → herdr_link {}                    # activate (idempotent)
 Agent A → herdr_link_send(to="B", ...)     # status "sent"
 Agent B → (receives inbound wrapper) herdr_link {}   # auto-activation trigger
-Agent B → herdr_link_send(to="A", reply_to=<received id>, ...)
+Agent B → herdr_link_send(to="A", message="result or done")
 Anyone  → herdr_link_close(agent="worker-a")   # in a later tool step after the final send
 ```
 
@@ -53,11 +53,26 @@ Herdr Link does not decide what agents should do, and it does not create, schedu
 
 ## Installation
 
+### Herdr plugin (operator tooling)
+
+herdr-link is listed on the official [Herdr plugin marketplace](https://herdr.dev/plugins/). Installing it as a Herdr plugin gives you an operator-facing `doctor` action for troubleshooting Link setups in any pane:
+
+```bash
+herdr plugin install LZHcode1986/herdr-link
+herdr plugin action invoke herdr-link.doctor   # env, self identity, same-workspace peers
+```
+
+The plugin action is read-only diagnostics; the Agent-facing protocol surface ships separately per runtime below.
+
+
 ### Pi (native extension)
 
 ```bash
-pi install git:github.com/LZHcode1986/herdr-link          # global
-pi install -l git:github.com/LZHcode1986/herdr-link       # project-local
+pi install npm:herdr-link          # global (recommended)
+pi install -l npm:herdr-link        # project-local
+
+# from source instead:
+pi install git:github.com/LZHcode1986/herdr-link
 ```
 
 Manual/dev loading:
@@ -120,7 +135,7 @@ The runtime process must be started by Herdr in a managed pane:
 | `SEND_FAILED` | Herdr did not accept the message prompt although guards passed |
 | `CLOSE_FAILED` | Target resolved to a pane but Herdr's pane close failed |
 
-Errors are local tool failures, not inter-agent message types; no auto-retry, no fallback, no pending state.
+Errors are local tool failures, not inter-agent message types; Link provides no acknowledgement, wait, poll, task/pending state, auto-retry, or fallback.
 
 ## Development
 
@@ -150,9 +165,9 @@ scripts/mcp-probe.mjs        stdio handshake debugging probe
 
 Layering rule: `protocol.ts` has zero Herdr IO; `herdr.ts` only drives the Herdr control plane (`execFile` argv arrays, no shell); `pi.ts` / `opencode.ts` / `mcp.ts` only do runtime wiring. Activation state lives in memory per runtime session: never persisted, never restored across sessions.
 
-## Non-goals (V1)
+## Scope and non-goals (V1)
 
-No agent creation/scheduling/recycling, model selection, workflow/task/stage state, business result schemas, evidence/receipt/review, persistent queues, cross-machine transport, permission approval, offline delivery, reliable-delivery acknowledgements, cross-session persistence, or **cross-workspace discovery/send/close** (that belongs to the official Herdr Skill / CLI control plane), and no workspace/topology management. Put business payloads in the `message` field; Link never interprets their semantics.
+Herdr Link is a same-workspace messaging/interoperability layer, not an agent lifecycle or task-management system. It does not provide agent creation/scheduling/recycling, model selection, workflow/task/stage state, business result schemas or evidence/receipt/review, acknowledgement/wait/poll/retry/pending-request semantics or reliable-delivery guarantees, persistent queues or cross-session persistence, cross-machine transport, permission approval, offline delivery, **cross-workspace discovery/send/close** (that belongs to the official Herdr Skill / CLI control plane), or workspace/topology management. Put business payloads in the `message` field; Link never interprets their semantics. See [`PROTOCOL.md` §9](./PROTOCOL.md#9-non-goals) for the canonical scope.
 
 ## License
 

package/README.zh-CN.md

@@ -7,7 +7,7 @@
 
 [English](./README.md) | **简体中文**
 
-Herdr Link 是运行在 Herdr 会话中的跨 Agent 按需互操作层。同一 workspace 内的 Agent 可以互相发现、交换协议化消息、关闭已完成的 pane——只通过 **3 个工具**，**零学习成本**。
+Herdr Link 是运行在 Herdr 会话中的跨 Agent 按需互操作层。同一 workspace 内的 Agent 可以互相发现、交换协议化消息、关闭已完成的 pane——通过一个 **lazy gateway** 暴露 **3 项核心能力**，**零学习成本**。
 
 提供 Pi（原生扩展）、OpenCode（插件 bundle）以及任意支持 MCP 的 Runtime 如 Claude Code / Codex / AGY（共享 stdio MCP server）的 Adapter。线上格式为 `herdr-link/1` 协议，唯一规范见 [`PROTOCOL.md`](./PROTOCOL.md)。
 
@@ -19,7 +19,7 @@ Herdr Link 是运行在 Herdr 会话中的跨 Agent 按需互操作层。同一
 - 这些推理过程**每次使用都在消耗 token 并增加延迟**；
 - 使用知识靠模型**反复自行推导**，而不是直接交给它。
 
-Herdr Link 把这一步彻底去掉。Adapter 直接给模型 3 个自描述工具，并自动注入一份紧凑的通信契约：
+Herdr Link 把这一步彻底去掉。Adapter 通过一个惰性 gateway 暴露 3 项核心能力，并自动注入一份紧凑的通信契约：
 
 | | 官方 Herdr Skill 路线 | 使用 Herdr Link |
 |---|---|---|
@@ -32,7 +32,7 @@ Herdr Link 把这一步彻底去掉。Adapter 直接给模型 3 个自描述工
 
 - **更少消耗。** 无需阅读、无需推导。dormant 态下模型只看到一个极小的 `herdr_link` gateway——无契约、无 schema；激活后也只注入一段简短契约，而不是一本手册。
 - **更快通讯。** 发现对端、发送协议化消息、关闭 pane 都是一次直接的工具调用——中间没有任何多步 CLI 编排。
-- **无感接入（零推理）。** 用户显式提出 Herdr 需求、或收到 inbound `herdr-link/1` 消息时自动激活；回复通过 `reply_to` 关联，Agent 不需要自己发明簿记机制。
+- **无感接入（零推理）。** 用户显式提出 Herdr 需求、或收到 inbound `herdr-link/1` 消息时自动激活；完成通过普通的 `herdr_link_send`：将指定结果发给 `from`；未指定结果时成功后精确发送 `done`；失败/阻塞时发送简短说明；只有明确要求不回复时才不发送。`done` 只是普通消息，不是 ACK、任务状态或投递回执。
 
 ## 工作方式
 
@@ -42,7 +42,7 @@ Herdr Link 把这一步彻底去掉。Adapter 直接给模型 3 个自描述工
 Agent A → herdr_link {}                    # 激活（幂等）
 Agent A → herdr_link_send(to="B", ...)     # status "sent"
 Agent B → （收到 inbound wrapper）herdr_link {}   # 自动激活触发
-Agent B → herdr_link_send(to="A", reply_to=<received id>, ...)
+Agent B → herdr_link_send(to="A", message="结果或 done")
 任意一方 → herdr_link_close(agent="worker-a")   # 最终 send 返回 sent 之后的工具步骤
 ```
 
@@ -56,8 +56,11 @@ Herdr Link 不决定 Agent 应该做什么，也不负责 Agent 的创建、调
 ### Pi（原生扩展）
 
 ```bash
-pi install git:github.com/LZHcode1986/herdr-link          # 全局
-pi install -l git:github.com/LZHcode1986/herdr-link       # 仅当前项目
+pi install npm:herdr-link          # 全局（推荐）
+pi install -l npm:herdr-link        # 仅当前项目
+
+# 改用源码安装：
+pi install git:github.com/LZHcode1986/herdr-link
 ```
 
 手动/开发加载：
@@ -120,7 +123,7 @@ MCP 同样是惰性呈现：非 Herdr 环境 `tools/list` 返回空集；Herdr m
 | `SEND_FAILED` | guard 通过后 Herdr 未接受 message prompt |
 | `CLOSE_FAILED` | 目标已解析到 pane，但 Herdr pane close 失败 |
 
-错误是本地 tool failure，不是跨 Agent 消息类型；不自动重试、不 fallback、不维护 pending 状态。
+错误是本地 tool failure，不是跨 Agent 消息类型；Link 不提供 ACK、wait、poll、task/pending 状态、自动重试或 fallback。
 
 ## 开发
 
@@ -150,9 +153,9 @@ scripts/mcp-probe.mjs        stdio 握手排障探针
 
 分层原则：`protocol.ts` 零 Herdr IO；`herdr.ts` 只做 Herdr 控制面调用（`execFile` argv 数组，无 shell）；`pi.ts` / `opencode.ts` / `mcp.ts` 各自只做 Runtime 接线。activation 是各 Adapter 内存中的 session 局部状态：不持久化、不跨 session 恢复。
 
-## Non-goals（V1）
+## 范围与非目标（V1）
 
-不提供：agent 创建/调度/回收、模型选择、workflow/task/stage 状态、业务结果 schema、evidence/receipt/review、持久消息队列、跨机器传输、权限审批、离线投递、可靠投递确认、跨 session 持久化、**跨 workspace 的 discovery/send/close**（属官方 Herdr Skill / CLI 控制面）、workspace/topology 管理面操作。业务 payload 放入 `message` 字段，Link 不解释其语义。
+Herdr Link 是同一 workspace 内的消息互操作层，不是 Agent 生命周期或任务管理系统。它不提供 agent 创建/调度/回收、模型选择、workflow/task/stage 状态、业务结果 schema/evidence/receipt/review、ACK/wait/poll/retry/pending-request 语义或可靠投递保证、持久队列或跨 session 持久化、跨机器传输、权限审批、离线投递、**跨 workspace 的 discovery/send/close**（属于官方 Herdr Skill / CLI 控制面），或 workspace/topology 管理。业务 payload 放入 `message` 字段；Link 不解释其语义。完整范围以 [`PROTOCOL.md` §9](./PROTOCOL.md#9-non-goals) 为准。
 
 ## 许可证
 

package/dist/herdr-link.mcp.js

@@ -11,7 +11,6 @@ import { randomBytes } from "node:crypto";
 // src/protocol.ts
 var PROTOCOL_ID = "herdr-link/1";
 var AGENT_NAME_RE = /^[a-z][a-z0-9_-]{0,31}$/;
-var MESSAGE_ID_RE = /^hl_[a-z0-9]+_[a-z0-9]+$/;
 var HERDR_LINK_GATEWAY = "herdr_link";
 var TOOL_PEERS = "herdr_link_peers";
 var TOOL_SEND = "herdr_link_send";
@@ -54,9 +53,6 @@ function createMessageId() {
 function isValidAgentName(name) {
   return AGENT_NAME_RE.test(name);
 }
-function isValidMessageId(id) {
-  return MESSAGE_ID_RE.test(id);
-}
 function buildEnvelope(input) {
   if (!isValidAgentName(input.from)) {
     throw new HerdrLinkError(
@@ -73,12 +69,6 @@ function buildEnvelope(input) {
   if (typeof input.message !== "string" || input.message.trim() === "") {
     throw new HerdrLinkError("SEND_FAILED", "message must be a non-empty string");
   }
-  if (input.reply_to !== void 0 && !isValidMessageId(input.reply_to)) {
-    throw new HerdrLinkError(
-      "SEND_FAILED",
-      "reply_to must be a valid herdr-link/1 message id when present"
-    );
-  }
   const envelope = {
     protocol: PROTOCOL_ID,
     id: createMessageId(),
@@ -86,9 +76,6 @@ function buildEnvelope(input) {
     to: input.to,
     message: input.message
   };
-  if (input.reply_to !== void 0) {
-    envelope.reply_to = input.reply_to;
-  }
   return envelope;
 }
 var INBOUND_WRAPPER_MARKER = `[${PROTOCOL_ID}]`;
@@ -98,14 +85,11 @@ function buildInboundWrapper(envelope) {
     `From: ${envelope.from}`,
     `Message id: ${envelope.id}`
   ];
-  if (envelope.reply_to !== void 0) {
-    lines.push(`Reply to: ${envelope.reply_to}`);
-  }
   lines.push(
     "",
     "The JSON object below is the complete herdr-link/1 envelope; the text around it is delivery metadata and is not part of the message.",
     `Treat the envelope's "message" field as content sent by the agent named in "from".`,
-    "If a reply is needed, activate the Herdr Link gateway when dormant, then use the active Herdr Link send capability to send to envelope.from with reply_to set to envelope.id.",
+    "If a reply is needed, activate the Herdr Link gateway when dormant, then use the active Herdr Link send capability to send to the agent named in envelope.from.",
     "",
     JSON.stringify(envelope)
   );
@@ -117,10 +101,11 @@ var COMMUNICATION_CONTRACT = `Herdr Link is the standard interoperability channe
 2. Use herdr_link_send to send messages to another agent.
 3. A message with protocol "herdr-link/1" is an inter-agent message.
 4. Treat its "message" field as content sent by the agent named in "from".
-5. When replying, send to the received "from" agent and set reply_to to the received "id".
-6. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
-7. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
-8. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.`;
+5. When replying, use herdr_link_send to the agent named in "from".
+6. When a received inter-agent message requests work, report the final outcome to the agent named in "from" using herdr_link_send. If specific reply content was requested, send that result; otherwise, after successful completion, send exactly "done". If the work cannot be completed, send a concise failure or blocker. If the sender explicitly requested no reply, do not send a completion message.
+7. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
+8. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
+9. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.`;
 
 // src/herdr.ts
 function attachCliOutput(error, stdout, stderr) {
@@ -400,15 +385,14 @@ async function listPeers() {
   }
   return { self: { name: self.name, state: self.agent_status }, peers };
 }
-async function sendMessage(to, message, reply_to) {
+async function sendMessage(to, message) {
   const self = await getSelfContext();
   const target = await getAgentContext(to);
   assertSameWorkspace(self, target);
   const envelope = buildEnvelope({
     from: self.name,
     to: target.name,
-    message,
-    reply_to
+    message
   });
   await runFor(["agent", "prompt", target.name, buildInboundWrapper(envelope)], "SEND_FAILED");
   return { status: "sent", id: envelope.id, to: target.name };
@@ -455,7 +439,7 @@ var INVALID_PARAMS = -32602;
 var NORMAL_MESSAGING_RULE = "Use Herdr Link, not raw Herdr CLI, pane ids, or terminal input, for normal inter-agent messaging.";
 var TOOL_DESCRIPTIONS = {
   [TOOL_PEERS]: `Discover live named peers in the same Herdr workspace; each state is advisory and Agent Names are the only addresses. ${NORMAL_MESSAGING_RULE}`,
-  [TOOL_SEND]: `Send a herdr-link/1 message to a live named peer in your own workspace. When replying, set reply_to to the received envelope id; status "sent" means Herdr accepted delivery. ${NORMAL_MESSAGING_RULE}`,
+  [TOOL_SEND]: `Send a herdr-link/1 message to a live named peer in your own workspace; status "sent" means Herdr accepted delivery. ${NORMAL_MESSAGING_RULE}`,
   [TOOL_CLOSE]: `Close the pane currently hosting a named same-workspace agent. If you need to send a final message before closing, complete the send first and call close in a later tool step. ${NORMAL_MESSAGING_RULE}`
 };
 var TOOL_INPUT_SCHEMAS = {
@@ -464,8 +448,7 @@ var TOOL_INPUT_SCHEMAS = {
     type: "object",
     properties: {
       to: { type: "string", description: "Target Herdr agent name" },
-      message: { type: "string", description: "Message payload" },
-      reply_to: { type: "string", description: "Message id being replied to" }
+      message: { type: "string", description: "Message payload" }
     },
     required: ["to", "message"]
   },
@@ -484,7 +467,7 @@ var FALLBACK_ERROR_CODE = {
 };
 var GATEWAY_TOOL = {
   name: HERDR_LINK_GATEWAY,
-  description: 'Herdr Link gateway. Activate only when the user explicitly asks to use Herdr or when handling an inbound Herdr Link message. Cross-agent messaging starts dormant: call this tool once with no arguments ({}) to activate it for this session \u2014 the host is notified via notifications/tools/list_changed and herdr_link_peers / herdr_link_send / herdr_link_close become available as regular tools. If your host did not refresh its tool list, keep dispatching through the gateway: {"action":"peers"}, {"action":"send","arguments":{"to":...,"message":...,"reply_to":...}}, or {"action":"close","arguments":{"agent":...}}.',
+  description: 'Herdr Link gateway. Activate only when the user explicitly asks to use Herdr or when handling an inbound Herdr Link message. Cross-agent messaging starts dormant: call this tool once with no arguments ({}) to activate it for this session \u2014 the host is notified via notifications/tools/list_changed and herdr_link_peers / herdr_link_send / herdr_link_close become available as regular tools. If your host did not refresh its tool list, keep dispatching through the gateway: {"action":"peers"}, {"action":"send","arguments":{"to":...,"message":...}}, or {"action":"close","arguments":{"agent":...}}.',
   inputSchema: {
     type: "object",
     properties: {
@@ -533,14 +516,6 @@ function requireStringArg(args, key, code) {
   }
   return value;
 }
-function optionalStringArg(args, key, code) {
-  const value = args[key];
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "string") {
-    throw new HerdrLinkError(code, `"${key}" must be a string when present`);
-  }
-  return value;
-}
 function createSerializedLineWriter(stream) {
   let tail = Promise.resolve();
   return (line) => {
@@ -602,8 +577,7 @@ function createRequestHandler(deps = {}) {
       case TOOL_SEND: {
         const to = requireStringArg(args, "to", "PEER_NOT_FOUND");
         const message = requireStringArg(args, "message", "SEND_FAILED");
-        const reply_to = optionalStringArg(args, "reply_to", "SEND_FAILED");
-        const sent = await runSend(to, message, reply_to);
+        const sent = await runSend(to, message);
         return { status: sent.status, id: sent.id, to: sent.to };
       }
       case TOOL_CLOSE: {

package/dist/herdr-link.opencode.js

@@ -8,7 +8,6 @@ import { randomBytes } from "node:crypto";
 // src/protocol.ts
 var PROTOCOL_ID = "herdr-link/1";
 var AGENT_NAME_RE = /^[a-z][a-z0-9_-]{0,31}$/;
-var MESSAGE_ID_RE = /^hl_[a-z0-9]+_[a-z0-9]+$/;
 var HERDR_LINK_GATEWAY = "herdr_link";
 var AGENT_STATES = ["idle", "working", "blocked", "done", "unknown"];
 function toAgentState(value) {
@@ -47,9 +46,6 @@ function createMessageId() {
 function isValidAgentName(name) {
   return AGENT_NAME_RE.test(name);
 }
-function isValidMessageId(id) {
-  return MESSAGE_ID_RE.test(id);
-}
 function buildEnvelope(input) {
   if (!isValidAgentName(input.from)) {
     throw new HerdrLinkError(
@@ -66,12 +62,6 @@ function buildEnvelope(input) {
   if (typeof input.message !== "string" || input.message.trim() === "") {
     throw new HerdrLinkError("SEND_FAILED", "message must be a non-empty string");
   }
-  if (input.reply_to !== void 0 && !isValidMessageId(input.reply_to)) {
-    throw new HerdrLinkError(
-      "SEND_FAILED",
-      "reply_to must be a valid herdr-link/1 message id when present"
-    );
-  }
   const envelope = {
     protocol: PROTOCOL_ID,
     id: createMessageId(),
@@ -79,9 +69,6 @@ function buildEnvelope(input) {
     to: input.to,
     message: input.message
   };
-  if (input.reply_to !== void 0) {
-    envelope.reply_to = input.reply_to;
-  }
   return envelope;
 }
 var INBOUND_WRAPPER_MARKER = `[${PROTOCOL_ID}]`;
@@ -91,14 +78,11 @@ function buildInboundWrapper(envelope) {
     `From: ${envelope.from}`,
     `Message id: ${envelope.id}`
   ];
-  if (envelope.reply_to !== void 0) {
-    lines.push(`Reply to: ${envelope.reply_to}`);
-  }
   lines.push(
     "",
     "The JSON object below is the complete herdr-link/1 envelope; the text around it is delivery metadata and is not part of the message.",
     `Treat the envelope's "message" field as content sent by the agent named in "from".`,
-    "If a reply is needed, activate the Herdr Link gateway when dormant, then use the active Herdr Link send capability to send to envelope.from with reply_to set to envelope.id.",
+    "If a reply is needed, activate the Herdr Link gateway when dormant, then use the active Herdr Link send capability to send to the agent named in envelope.from.",
     "",
     JSON.stringify(envelope)
   );
@@ -110,10 +94,11 @@ var COMMUNICATION_CONTRACT = `Herdr Link is the standard interoperability channe
 2. Use herdr_link_send to send messages to another agent.
 3. A message with protocol "herdr-link/1" is an inter-agent message.
 4. Treat its "message" field as content sent by the agent named in "from".
-5. When replying, send to the received "from" agent and set reply_to to the received "id".
-6. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
-7. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
-8. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.`;
+5. When replying, use herdr_link_send to the agent named in "from".
+6. When a received inter-agent message requests work, report the final outcome to the agent named in "from" using herdr_link_send. If specific reply content was requested, send that result; otherwise, after successful completion, send exactly "done". If the work cannot be completed, send a concise failure or blocker. If the sender explicitly requested no reply, do not send a completion message.
+7. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
+8. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
+9. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.`;
 
 // src/herdr.ts
 function attachCliOutput(error, stdout, stderr) {
@@ -393,15 +378,14 @@ async function listPeers() {
   }
   return { self: { name: self.name, state: self.agent_status }, peers };
 }
-async function sendMessage(to, message, reply_to) {
+async function sendMessage(to, message) {
   const self = await getSelfContext();
   const target = await getAgentContext(to);
   assertSameWorkspace(self, target);
   const envelope = buildEnvelope({
     from: self.name,
     to: target.name,
-    message,
-    reply_to
+    message
   });
   await runFor(["agent", "prompt", target.name, buildInboundWrapper(envelope)], "SEND_FAILED");
   return { status: "sent", id: envelope.id, to: target.name };
@@ -439,7 +423,7 @@ async function closeAgentPane(agentName) {
 // src/opencode.ts
 var GATEWAY_PRESENTATION_APPENDIX = `In this runtime the active Herdr Link capabilities are dispatched through the single herdr_link gateway.
 - Use herdr_link with action "peers" to list live same-workspace agents.
-- Use herdr_link with action "send", to, message, and reply_to when replying.
+- Use herdr_link with action "send" with to and message to deliver an inter-agent message or ordinary reply.
 - Use herdr_link with action "close" and an Agent Name only after any final send returns status "sent", in a later tool step.`;
 var GATEWAY_CONTRACT = `${COMMUNICATION_CONTRACT}
 
@@ -468,14 +452,13 @@ var herdrLinkPlugin = async () => {
   return {
     tool: {
       [HERDR_LINK_GATEWAY]: tool({
-        description: `Herdr Link cross-agent communication gateway (herdr-link/1). Activate only when the user explicitly asks to use Herdr or when handling an inbound Herdr Link message. Call once with no arguments {} to activate Herdr Link for this session; the response lists capabilities. Then pass action "peers" to list live same-workspace agents, "send" with to + message (plus reply_to when replying) to deliver an inter-agent message, or "close" with agent to close a named agent's pane \u2014 only after any final send has returned status "sent", and in a later tool step.`,
+        description: `Herdr Link cross-agent communication gateway (herdr-link/1). Activate only when the user explicitly asks to use Herdr or when handling an inbound Herdr Link message. Call once with no arguments {} to activate Herdr Link for this session; the response lists capabilities. Then pass action "peers" to list live same-workspace agents, "send" with to + message to deliver an inter-agent message or ordinary reply, or "close" with agent to close a named agent's pane \u2014 only after any final send has returned status "sent", and in a later tool step.`,
         args: {
           action: tool.schema.enum(["peers", "send", "close"]).optional().describe(
             'Operation to run: "peers" | "send" | "close". Omit action entirely (call with {}) to activate Herdr Link for this session.'
           ),
           to: tool.schema.string().optional().describe('Target agent name; required for action "send".'),
           message: tool.schema.string().optional().describe('Message payload; required for action "send".'),
-          reply_to: tool.schema.string().optional().describe('Message id being replied to; optional, only with action "send".'),
           agent: tool.schema.string().optional().describe('Target agent name; required for action "close".')
         },
         async execute(args, context) {
@@ -499,7 +482,7 @@ var herdrLinkPlugin = async () => {
               failWith(new HerdrLinkError("SEND_FAILED", '"message" must be a non-empty string'), "SEND_FAILED");
             }
             try {
-              const envelope = await sendMessage(args.to, args.message, args.reply_to);
+              const envelope = await sendMessage(args.to, args.message);
               return jsonResult({ status: "sent", id: envelope.id, to: envelope.to });
             } catch (error) {
               failWith(error, "SEND_FAILED");

package/docs/mcp-wiring.md

@@ -59,10 +59,11 @@ Herdr Link is the standard interoperability channel between agents running in th
 2. Use herdr_link_send to send messages to another agent.
 3. A message with protocol "herdr-link/1" is an inter-agent message.
 4. Treat its "message" field as content sent by the agent named in "from".
-5. When replying, send to the received "from" agent and set reply_to to the received "id".
-6. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
-7. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
-8. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.
+5. When replying, use herdr_link_send to the agent named in "from".
+6. When a received inter-agent message requests work, report the final outcome to the agent named in "from" using herdr_link_send. If specific reply content was requested, send that result; otherwise, after successful completion, send exactly "done". If the work cannot be completed, send a concise failure or blocker. If the sender explicitly requested no reply, do not send a completion message.
+7. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
+8. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
+9. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.
 ```
 
 ### 1.2 Codex 附录（prefix 型，`buildMcpPrefixedCommunicationContract("herdr_link")`）
@@ -100,7 +101,7 @@ Use:
 
 ## 2. Claude Code（launcher + shared MCP）
 
-> **状态：VALIDATED（happy path，2026-08-24）**——CC 2.1.241 已在独立 Herdr tab 的新 pane 中完成 MCP handshake、工具呈现、Contract launcher 注入及 model-facing `peers → send(reply_to)` 任务闭环。**尚未实测**：lazy activation 呈现（须按 §5 重跑冒烟）与 model-facing error path（`PEER_NOT_FOUND` isError 透传）。共享 MCP server 无需 CC 专属代码。
+> **状态：VALIDATED（开发与验证已完成）**——CC 2.1.241 已在独立 Herdr tab 的新 pane 中完成 MCP handshake、工具呈现、Contract launcher 注入及 model-facing `peers → send` 任务闭环；lazy activation 呈现与 model-facing error path（`PEER_NOT_FOUND` isError 透传）亦已实测通过。共享 MCP server 无需 CC 专属代码。
 > **命名约束**：CC 的 MCP server key 必须使用 `herdr_link`（下划线）；模型呈现为 `mcp__herdr_link__<canonical>`。`serverInfo.name` 仍为 `herdr-link`，两者不可混用。allowlist 使用 `mcp__herdr_link__*`。
 
 注册 MCP server（二选一）：
@@ -272,4 +273,4 @@ printf '%s\n%s\n%s\n%s\n' \
 | 5 | AGY hooks.json 写顶层 `"PreInvocation"` 不生效 | AGY 格式为按集成名分组：`{"<name>": {"PreInvocation": [...]}}`，多组同名事件顺序合并 | 用独立组名（如 `"herdr-link"`），与 herdr 官方集成组并存 |
 | 6 | Host 对 `notifications/tools/list_changed` 不重新拉取 `tools/list` | 各 Host 刷新行为不一（工程确认项） | 保持 gateway 显式 action 分发（§总览 fallback 行）；canonical 语义不变 |
 
-E2E 记录：Codex TUI 与 AGY 曾各自完成 peers → send(reply_to 关联) → brain 收 envelope 全闭环、`PEER_NOT_FOUND` isError 文本透传一致、`herdr_link_close` 返回 `{status:"closed",agent}`——**该记录取证于常驻三工具呈现时代**；lazy activation 呈现（dormant 单工具、listChanged、gateway dispatch）尚未有同等真机记录，发布前须按 §5 重跑。
+E2E 记录：Codex TUI 与 AGY 曾各自完成 peers → send → brain 收 envelope 全闭环、`PEER_NOT_FOUND` isError 文本透传一致、`herdr_link_close` 返回 `{status:"closed",agent}`——**该记录取证于常驻三工具呈现时代**；lazy activation 呈现（dormant 单工具、listChanged、gateway dispatch）尚未有同等真机记录，发布前须按 §5 重跑。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "herdr-link",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "pi": {
     "extensions": [
       "./src/pi.ts"

package/src/herdr.ts

@@ -471,7 +471,6 @@ export async function listPeers(): Promise<PeerDirectory> {
 export async function sendMessage(
   to: string,
   message: string,
-  reply_to?: string,
 ): Promise<{ status: "sent"; id: string; to: string }> {
   const self = await getSelfContext();
   const target = await getAgentContext(to);
@@ -481,7 +480,6 @@ export async function sendMessage(
     from: self.name,
     to: target.name,
     message,
-    reply_to,
   });
 
   await runFor(["agent", "prompt", target.name, buildInboundWrapper(envelope)], "SEND_FAILED");

package/src/mcp.ts

@@ -76,7 +76,7 @@ const NORMAL_MESSAGING_RULE = "Use Herdr Link, not raw Herdr CLI, pane ids, or t
 const TOOL_DESCRIPTIONS: Record<CanonicalToolName, string> = {
   [TOOL_PEERS]: `Discover live named peers in the same Herdr workspace; each state is advisory and Agent Names are the only addresses. ${NORMAL_MESSAGING_RULE}`,
   [TOOL_SEND]:
-    `Send a herdr-link/1 message to a live named peer in your own workspace. When replying, set reply_to to the received envelope id; status "sent" means Herdr accepted delivery. ${NORMAL_MESSAGING_RULE}`,
+    `Send a herdr-link/1 message to a live named peer in your own workspace; status "sent" means Herdr accepted delivery. ${NORMAL_MESSAGING_RULE}`,
   [TOOL_CLOSE]:
     `Close the pane currently hosting a named same-workspace agent. If you need to send a final message before closing, complete the send first and call close in a later tool step. ${NORMAL_MESSAGING_RULE}`,
 };
@@ -88,7 +88,6 @@ const TOOL_INPUT_SCHEMAS: Record<CanonicalToolName, Record<string, unknown>> = {
     properties: {
       to: { type: "string", description: "Target Herdr agent name" },
       message: { type: "string", description: "Message payload" },
-      reply_to: { type: "string", description: "Message id being replied to" },
     },
     required: ["to", "message"],
   },
@@ -120,7 +119,7 @@ const GATEWAY_TOOL: { name: typeof HERDR_LINK_GATEWAY; description: string; inpu
     "({}) to activate it for this session — the host is notified via notifications/tools/list_changed " +
     "and herdr_link_peers / herdr_link_send / herdr_link_close become available as regular tools. " +
     'If your host did not refresh its tool list, keep dispatching through the gateway: {"action":"peers"}, ' +
-    '{"action":"send","arguments":{"to":...,"message":...,"reply_to":...}}, or ' +
+    '{"action":"send","arguments":{"to":...,"message":...}}, or ' +
     '{"action":"close","arguments":{"agent":...}}.',
   inputSchema: {
     type: "object",
@@ -187,19 +186,6 @@ function requireStringArg(args: Record<string, unknown>, key: string, code: Link
   return value;
 }
 
-function optionalStringArg(
-  args: Record<string, unknown>,
-  key: string,
-  code: LinkErrorCode,
-): string | undefined {
-  const value = args[key];
-  if (value === undefined || value === null) return undefined;
-  if (typeof value !== "string") {
-    throw new HerdrLinkError(code, `"${key}" must be a string when present`);
-  }
-  return value;
-}
-
 /* ------------------------------------------------------------------ *
  * stdout plumbing
  *
@@ -314,8 +300,7 @@ export function createRequestHandler(
       case TOOL_SEND: {
         const to = requireStringArg(args, "to", "PEER_NOT_FOUND");
         const message = requireStringArg(args, "message", "SEND_FAILED");
-        const reply_to = optionalStringArg(args, "reply_to", "SEND_FAILED");
-        const sent = await runSend(to, message, reply_to);
+        const sent = await runSend(to, message);
         return { status: sent.status, id: sent.id, to: sent.to };
       }
       case TOOL_CLOSE: {

package/src/opencode.ts

@@ -42,7 +42,7 @@ import {
 /** Runtime-specific active presentation; the semantic Contract remains canonical. */
 const GATEWAY_PRESENTATION_APPENDIX = `In this runtime the active Herdr Link capabilities are dispatched through the single herdr_link gateway.
 - Use herdr_link with action "peers" to list live same-workspace agents.
-- Use herdr_link with action "send", to, message, and reply_to when replying.
+- Use herdr_link with action "send" with to and message to deliver an inter-agent message or ordinary reply.
 - Use herdr_link with action "close" and an Agent Name only after any final send returns status "sent", in a later tool step.`;
 
 const GATEWAY_CONTRACT = `${COMMUNICATION_CONTRACT}\n\n${GATEWAY_PRESENTATION_APPENDIX}`;
@@ -92,7 +92,7 @@ export const herdrLinkPlugin: Plugin = async () => {
         description:
           "Herdr Link cross-agent communication gateway (herdr-link/1). Activate only when the user explicitly asks to use Herdr or when handling an inbound Herdr Link message. " +
           'Call once with no arguments {} to activate Herdr Link for this session; the response lists capabilities. ' +
-            'Then pass action "peers" to list live same-workspace agents, "send" with to + message (plus reply_to when replying) to deliver an inter-agent message, or "close" with agent to close a named agent\'s pane — ' +
+            'Then pass action "peers" to list live same-workspace agents, "send" with to + message to deliver an inter-agent message or ordinary reply, or "close" with agent to close a named agent\'s pane — ' +
             'only after any final send has returned status "sent", and in a later tool step.',
         args: {
           action: tool.schema
@@ -109,10 +109,6 @@ export const herdrLinkPlugin: Plugin = async () => {
             .string()
             .optional()
             .describe('Message payload; required for action "send".'),
-          reply_to: tool.schema
-            .string()
-            .optional()
-            .describe('Message id being replied to; optional, only with action "send".'),
           agent: tool.schema
             .string()
             .optional()
@@ -143,7 +139,7 @@ export const herdrLinkPlugin: Plugin = async () => {
               failWith(new HerdrLinkError("SEND_FAILED", '"message" must be a non-empty string'), "SEND_FAILED");
             }
             try {
-              const envelope = await sendMessage(args.to, args.message, args.reply_to);
+              const envelope = await sendMessage(args.to, args.message);
               return jsonResult({ status: "sent", id: envelope.id, to: envelope.to });
             } catch (error) {
               failWith(error, "SEND_FAILED");

package/src/pi.ts

@@ -38,7 +38,6 @@ const PEERS_PARAMETERS = Type.Object({});
 const SEND_PARAMETERS = Type.Object({
   to: Type.String(),
   message: Type.String(),
-  reply_to: Type.Optional(Type.String()),
 });
 const CLOSE_PARAMETERS = Type.Object({
   agent: Type.String(),
@@ -93,11 +92,11 @@ export default function (pi: ExtensionAPI): void {
     name: "herdr_link_send",
     label: "Herdr Link Send",
     description:
-      'Send an inter-agent message (protocol herdr-link/1) to another agent through the cross-agent communication channel. status "sent" means Herdr accepted delivery, not that the peer finished its task. When replying, set reply_to to the received message id.',
+      'Send an inter-agent message (protocol herdr-link/1) to another agent through the cross-agent communication channel. status "sent" means Herdr accepted delivery, not that the peer finished its task.',
     parameters: SEND_PARAMETERS,
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       try {
-        const envelope = await sendMessage(params.to, params.message, params.reply_to);
+        const envelope = await sendMessage(params.to, params.message);
         return toolResult({ status: "sent", id: envelope.id, to: envelope.to });
       } catch (error) {
         rethrowToolError(error, "SEND_FAILED");

package/src/protocol.ts

@@ -89,7 +89,6 @@ export interface HerdrLinkEnvelope {
   id: string;
   from: string;
   to: string;
-  reply_to?: string;
   message: string;
 }
 
@@ -149,7 +148,6 @@ export interface BuildEnvelopeInput {
   from: string;
   to: string;
   message: string;
-  reply_to?: string;
 }
 
 /**
@@ -173,12 +171,6 @@ export function buildEnvelope(input: BuildEnvelopeInput): HerdrLinkEnvelope {
   if (typeof input.message !== "string" || input.message.trim() === "") {
     throw new HerdrLinkError("SEND_FAILED", "message must be a non-empty string");
   }
-  if (input.reply_to !== undefined && !isValidMessageId(input.reply_to)) {
-    throw new HerdrLinkError(
-      "SEND_FAILED",
-      "reply_to must be a valid herdr-link/1 message id when present",
-    );
-  }
   const envelope: HerdrLinkEnvelope = {
     protocol: PROTOCOL_ID,
     id: createMessageId(),
@@ -186,9 +178,6 @@ export function buildEnvelope(input: BuildEnvelopeInput): HerdrLinkEnvelope {
     to: input.to,
     message: input.message,
   };
-  if (input.reply_to !== undefined) {
-    envelope.reply_to = input.reply_to;
-  }
   return envelope;
 }
 
@@ -209,8 +198,7 @@ export function isHerdrLinkEnvelope(value: unknown): value is HerdrLinkEnvelope
     typeof v.to === "string" &&
     isValidAgentName(v.to) &&
     typeof v.message === "string" &&
-    v.message.trim() !== "" &&
-    (v.reply_to === undefined || (typeof v.reply_to === "string" && isValidMessageId(v.reply_to)))
+    v.message.trim() !== ""
   );
 }
 
@@ -219,7 +207,7 @@ export function isHerdrLinkEnvelope(value: unknown): value is HerdrLinkEnvelope
  *
  * `herdr agent prompt` carries a self-describing wrapper around the
  * envelope so a dormant receiver (adapter loaded, model not mid-exchange)
- * can recognize the delivery and activate a reply addressed by reply_to.
+ * can recognize the delivery and activate a response addressed to envelope.from.
  * The wrapper is transport dressing ONLY: the envelope keeps exactly the
  * minimal herdr-link/1 fields and is embedded verbatim as the final line.
  * ------------------------------------------------------------------ */
@@ -234,14 +222,11 @@ export function buildInboundWrapper(envelope: HerdrLinkEnvelope): string {
     `From: ${envelope.from}`,
     `Message id: ${envelope.id}`,
   ];
-  if (envelope.reply_to !== undefined) {
-    lines.push(`Reply to: ${envelope.reply_to}`);
-  }
   lines.push(
     "",
     "The JSON object below is the complete herdr-link/1 envelope; the text around it is delivery metadata and is not part of the message.",
     'Treat the envelope\'s "message" field as content sent by the agent named in "from".',
-    "If a reply is needed, activate the Herdr Link gateway when dormant, then use the active Herdr Link send capability to send to envelope.from with reply_to set to envelope.id.",
+    "If a reply is needed, activate the Herdr Link gateway when dormant, then use the active Herdr Link send capability to send to the agent named in envelope.from.",
     "",
     JSON.stringify(envelope),
   );
@@ -270,7 +255,7 @@ export function extractInboundEnvelope(text: string): HerdrLinkEnvelope | undefi
 
 /**
  * Active Agent Communication Contract injected verbatim into the model.
- * Compact form: same-workspace addressing, send/reply/close semantics only.
+ * Compact form: same-workspace addressing, send/reply/completion/close semantics.
  */
 export const COMMUNICATION_CONTRACT = `Herdr Link is the standard interoperability channel between agents running in the same Herdr workspace.
 
@@ -278,7 +263,8 @@ export const COMMUNICATION_CONTRACT = `Herdr Link is the standard interoperabili
 2. Use herdr_link_send to send messages to another agent.
 3. A message with protocol "herdr-link/1" is an inter-agent message.
 4. Treat its "message" field as content sent by the agent named in "from".
-5. When replying, send to the received "from" agent and set reply_to to the received "id".
-6. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
-7. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
-8. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.`;
+5. When replying, use herdr_link_send to the agent named in "from".
+6. When a received inter-agent message requests work, report the final outcome to the agent named in "from" using herdr_link_send. If specific reply content was requested, send that result; otherwise, after successful completion, send exactly "done". If the work cannot be completed, send a concise failure or blocker. If the sender explicitly requested no reply, do not send a completion message.
+7. Use herdr_link_close only when you have already decided that a named agent's pane should be closed. If a final message is needed, call close in a later tool step after herdr_link_send returns "sent".
+8. Never use a raw pane id, UI focus, terminal input, or the Herdr CLI as an inter-agent channel; agent names are the only addresses.
+9. Agents outside your workspace are invisible: they never appear in peers and messages addressed to them fail.`;