Agent→Agent 不自动转发 + 提示词区分新活/回复/补投

## 设计规则：Agent 之间不自动转发

自动转发存在的理由是「人不该等模型记得调 send_mail」—— 收件方是人时这是
纯收益。**收件方是另一个 Agent 时这个理由不成立，而且有害**：双方的插件都
会自动回一封，于是两个模型都以为「我只要把话说完就行」，实际在持续互相唤醒。
生产实测 pi 与 dsh 客套 6 轮直到撞上连续 relay 跳数上限。

规则现在写死在共用模块 `lib/relay-policy.js`（三平台逐字节相同）：
- `autoRelayDecision` — 插件该不该替模型开口
- `replyInstruction` — 提示词怎么跟模型说（人类 vs Agent 各一套措辞）
- `inboundHeadline` — 进来的是新活、回复、还是补投

`from_human` 缺失时保守按 Agent 处理：宁可让模型多调一次 send_mail，
也不能承诺一个不会发生的自动回信让发件方白等。

## Gateway 侧：`in_reply_to` + `from_human`

- `notify.Mail` 新增 `ParentMailID`（非空 = 这是对收件方某封信的回复）
- `notify.Mail` 新增 `FromHuman`（走 `repo.IsHumanUser`）
- SSE payload 里叫 `in_reply_to` / `from_human`
- 四个调用点全部传入：handler/mail（转发后产出的邮件，parentMailID 从
  resolveTarget 取）、handler/me（同理）、handler/forward（传空串，
  因为对收件方而言那封原邮件不在它的线索里）、scheduler/calendar（传空串）
- `ListInbox` 的 SELECT 加 `EXISTS (SELECT 1 FROM users u WHERE u.username = m.from_name)`
  → `models.Mail.FromHuman`，让补拉路径也有这个信号

## 提示词分流

三种处境各一套标题：
- 新活（人类）：「你收到一封新邮件」+ 「回信不用你自己发：…」
- 新活（Agent）：「你收到一封新邮件（对方是一个 Agent）」+ 「插件不会替你
  回信。需要回复时你必须自己调 send_mail…请先判断是否真的需要回复」
- 回复到了：「你上一封信的回复到了。**这不是新任务**。」
- 补投：在标题里说明「离线期间积压」

## homeagent 特殊处理

Go 插件不能直接 `import('../lib/relay-policy.js')`，因此新增 `relay_policy.go`
（Go 对应物）+ `relay_policy_test.go`（11 例，逐条对齐 Node 侧判据）。
`sseLoop` / `catchUp` 两条路径都接上。

## `mailEvent` 命名类型

homeagent 的 SSE 事件解析 / handleNewMail / handlePermissionDecision 三处
原来各写一遍匿名 struct（字段列表几乎相同），加 `from_human` / `in_reply_to`
时漏改一处 → 编译报错但错误信息是两串几乎相同的字段列表，极难定位。
提成 `mailEvent` 命名类型：一处改、三处跟着走。

## 测试

- `lib/relay-policy.test.mjs`（Node）16 例：含「replyInstruction 与
  autoRelayDecision 不得互相矛盾」「Agent 来信的标题要点名且回复要明确反对」
- `relay_policy_test.go`（Go）11 例：逐条对齐 Node 侧
- `turn.test.mjs` +3 例：from_human 缺失时按 Agent 处理 / Agent 来信时改口 /
  回复到了说「不是新任务」；删掉两条旧的「必定自动转发」断言
- 共用脚本 `check-shared-libs.sh` +1 个文件（relay-policy）
- pi 288 / dsh 241 / opencode 217 / homeagent 14 / gateway 8 包全绿

plugins/opencode-mail-bridge/index.js

@@ -34,6 +34,7 @@ import {
   shouldSkipAutoRelay,
 } from "./lib/relay-dedup.js";
 import { adoptedSessionID, adoptMissingMessage } from "./lib/adopt.js";
+import { autoRelayDecision, replyInstruction, inboundHeadline } from "./lib/relay-policy.js";
 import { appendRenameProposal, renameProposalNote } from "./lib/rename-proposal.js";
 // opencode 原生支持三态权限，免批由它自己记（response:"always"），
 // 所以这里只借用决策文本的判定，不需要 createGrantStore。
@@ -706,6 +707,23 @@ async function relaySummary(client, directory, sessionID) {
   if (!mailSessionID) return null;              // 不是邮件驱动的会话，不碰
   if (!mailDrivenSessions.has(sessionID)) return null;
 
+  // 回信地址：这轮是谁发起的就回给谁。取该会话最近一封来信的发件人。
+  const ctx = mailContexts.get(mailSessionID);
+
+  // **只给人类来信自动转发**（见 lib/relay-policy.js）。
+  //
+  // 对方是 Agent 时它那边的插件也会自动回一封，于是两个模型都以为「我只要
+  // 把话说完就行」，实际在持续互相唤醒 —— 生产实测 pi 与 dsh 客套 6 轮直到
+  // 撞上连续 relay 跳数上限。放在取消息列表**之前**判：少一次网关往返。
+  const policy = autoRelayDecision({
+    fromHuman: ctx?.fromHuman === true,
+    replyTo: ctx?.replyTo,
+  });
+  if (!policy.relay) {
+    console.error(`[mail-bridge] 本轮不自动转发：${policy.reason}`);
+    return null;
+  }
+
   // 取最后一条 assistant 文本消息
   const listed = await client.session.messages({
     path: { id: sessionID },
@@ -731,10 +749,6 @@ async function relaySummary(client, directory, sessionID) {
   // 本地去重（服务端另有 relay_key 幂等兜底，这里只是少打一次网关）
   if (relayedSummaries.get(sessionID) === last.id) return null;
 
-  // 回信地址：这轮是谁发起的就回给谁。取该会话最近一封来信的发件人。
-  const ctx = mailContexts.get(mailSessionID);
-  if (!ctx?.replyTo) return null;
-
   // 模型这一轮已经亲手回过这条线索 → 不再自动转发。
   //
   // 否则收件箱里会出现两封说同一件事的邮件（生产实测：311 字节与 342 字节各一封，
@@ -831,31 +845,44 @@ async function deliverMail(client, directory, data, kind) {
   // 不清的话，上一轮亲手回过信会永久压掉这个会话之后所有的自动转发。
   explicitSends.delete(sessionID);
 
-  // 记住这轮该回给谁：idle 时 relaySummary 靠它决定收件人与 reply_to。
+  // 回信上下文：idle 时 relaySummary 靠它决定收件人与 reply_to。
   // 一个会话里可能来过多封信，只保留最近那封 —— 回信要落回最新的线索。
+  //
+  // 多记两个服务端信号：
+  //   fromHuman  —— 只有人类来信才自动转发（见 lib/relay-policy.js）
+  //   inReplyTo  —— 这封是不是对本方某封信的回复
+  // 不存进上下文的话，relaySummary 那一刻拿不到它们（那个函数只有 sessionID）。
   if (kind === "mail" && data.session_id) {
     mailContexts.set(data.session_id, {
       replyTo: data.from_name || "",
       subject: data.subject || "",
       mailID: data.mail_id || "",
+      fromHuman: data.from_human === true,
+      inReplyTo: data.in_reply_to || "",
     });
   }
 
+  const fromHuman = data.from_human === true;
   const text = kind === "permission"
     ? `你之前发起的权限请求已有结论：${data.decision}（决策人：${data.decided_by || "用户"}）。请据此继续后续工作。`
     : [
-        reused ? `本会话收到一封新邮件（AgentMail 续谈）。` : `你收到一封新邮件（AgentMail）。`,
+        inboundHeadline({
+          inReplyTo: data.in_reply_to,
+          fromHuman,
+          catchup: data.catchup,
+          reused,
+        }),
         ``,
         `发件人：${data.from_name || "unknown"}`,
         `主题：${data.subject || "(无主题)"}`,
         `邮件 ID：${data.mail_id || "unknown"}`,
+        ...(data.in_reply_to ? [`回的是你那封：${data.in_reply_to}`] : []),
         `身份：你是 ${AGENT_NAME}`,
+        ...(data.reply_address ? [`回信地址：${data.reply_address}`] : []),
         ``,
         `请先调用 read_inbox 读取完整正文（附带附件清单，如有附件可用 download_attachment 取回），然后处理其中的请求。`,
         ``,
-        `**回信不用你自己发**：你把本轮工作做完、把结论正常说出来就行，`,
-        `插件会在这一轮结束时自动把你最后那段话作为回信发回给 ${data.from_name || "发件人"}（不消耗你的发信配额）。`,
-        `只有在需要主动联系其他人、或要带附件时才调用 send_mail。`,
+        ...replyInstruction({ fromHuman, replyAddress: data.reply_address }),
       ].join("\n");
 
   // 按管理员划定的范围逐个尝试，全部失败才回一封说明失败原因的邮件。

plugins/opencode-mail-bridge/lib/relay-policy.js

@@ -0,0 +1,120 @@
+// 自动转发的**适用范围**，以及据此该给模型说什么话。
+//
+// 单独一个文件而不是放在入口里导出：**opencode 会把插件入口模块的每一个导出
+// 都当成插件工厂**（`Object.values(mod)` 逐个检查是不是函数），多导出一个函数
+// 就会让整个插件加载失败。因此入口只 `export default`，判断逻辑一律搁在这里。
+//
+// # 为什么 Agent → Agent 不自动转发
+//
+// 自动转发存在的理由是「人不该等模型记得调 send_mail」：人发一封信出去，
+// 模型把活干完、话说完，插件替它把结论搬进邮件。收件方是人时这是纯收益。
+//
+// 收件方是**另一个 Agent** 时这个理由不成立，而且有害：对方的插件同样会自动
+// 回一封，于是两个模型都以为「我只要把话说完就行」，实际上在持续互相唤醒。
+// 生产实测过一条完整的客套链（pi 转发给 dsh，dsh 回确认，pi 又确认那个确认，
+// 一直到第 6 封撞上连续 relay 跳数上限才停）：
+//
+//   pi→dsh   parent=24be32e5   转发
+//   dsh→pi   parent=bf79f8fe   已收到转发
+//   pi→dsh   parent=2700bd0a   收到你的确认
+//   dsh→pi   parent=34127884   确认闭环
+//   pi→dsh   parent=34058c13   …
+//   dsh→pi   parent=9590bf16   ← 被 hop 上限拦下
+//
+// 每一封都不是错的，每一封都没有新信息。跳数上限是最后一道闸，不是设计意图。
+//
+// 因此规则是：**Agent 之间通信必须由模型主动调 send_mail。**
+// 插件不再代它开口 —— 该说话的时候它会说，没什么要说的时候就该安静。
+//
+// 副作用是好的：模型必须自己决定「这值得回一封信吗」，而那正是它该做的判断。
+
+/** 取三维地址的名字段：admin@root.alias -> admin */
+export function addrName(addr) {
+  return String(addr || "").split("@")[0].trim();
+}
+
+/**
+ * 这一轮的结论该不该由插件自动转发出去。
+ *
+ * @param {object} ctx
+ * @param {boolean} ctx.fromHuman 来信方是人类用户（SSE 的 `from_human`）
+ * @param {string}  [ctx.replyTo] 自动转发本来要发给谁
+ * @returns {{relay: boolean, reason: string}}
+ *   reason 供日志用 —— 「本轮没有回信」必须能在日志里查到原因，
+ *   否则它与「模型没说话」「转发失败」三种情形长得一样。
+ */
+export function autoRelayDecision(ctx) {
+  const { fromHuman, replyTo } = ctx || {};
+  if (!replyTo) {
+    return { relay: false, reason: "不知道回给谁" };
+  }
+  if (!fromHuman) {
+    return {
+      relay: false,
+      reason: `来信方 ${addrName(replyTo)} 是 Agent，按约定不自动转发（Agent 间通信须由模型主动 send_mail）`,
+    };
+  }
+  return { relay: true, reason: "" };
+}
+
+/**
+ * 提示词里关于「回信怎么发」的那句话。
+ *
+ * 必须与 `autoRelayDecision` 一致 —— 这是同一件事的两个出口，分开写必然分叉。
+ * 而分叉的代价是模型被骗：它以为插件会替它回信，于是把话说完就停手，
+ * 而实际上那封信永远不会发出去，发件方一直等着。
+ *
+ * @param {object} ctx
+ * @param {boolean} ctx.fromHuman
+ * @param {string}  [ctx.replyAddress] 服务端算好的回信地址
+ * @returns {string[]} 若干行，直接拼进提示词
+ */
+export function replyInstruction(ctx) {
+  const { fromHuman, replyAddress } = ctx || {};
+  if (fromHuman) {
+    return [
+      "**回信不用你自己发**：把这一轮做完、把结论说出来就行，",
+      "插件会在这一轮结束时把你最后那段话作为回信发回去（不消耗你的发信配额）。",
+      "只有在需要主动联系其他人、或要带附件时才调用 send_mail。",
+    ];
+  }
+  return [
+    "**这封信来自另一个 Agent，插件不会替你回信。**",
+    "需要回复时你必须自己调用 send_mail" +
+      (replyAddress ? `（回信地址：${replyAddress}）` : "") + "；",
+    "把话说完并不会让对方收到任何东西。",
+    "也请先判断这封信是否真的需要回复 —— 单纯的「收到」「确认」会让两个 Agent",
+    "无休止地互相客套，那对谁都没有价值。有实质结论或有事要问时才回。",
+  ];
+}
+
+/**
+ * 描述「进来的这封是什么」。
+ *
+ * 在此之前提示词一律说「你收到一封新邮件」，于是模型分不清三种处境：
+ * 有人派了新活、我上封信的回复到了、离线期间积压的补投。
+ * 第二种被当成第一种时，模型会把一句「已收到」当成待办再处理一遍。
+ *
+ * @param {object} ctx
+ * @param {string}  [ctx.inReplyTo] 非空 = 这是对本方某封信的回复（SSE 的 `in_reply_to`）
+ * @param {boolean} ctx.fromHuman
+ * @param {boolean} [ctx.catchup]  离线期间积压后补投的
+ * @param {boolean} [ctx.reused]   投进一条已存在的会话（续谈）
+ * @returns {string} 提示词第一行
+ */
+export function inboundHeadline(ctx) {
+  const { inReplyTo, fromHuman, catchup, reused } = ctx || {};
+  const who = fromHuman ? "" : "（对方是一个 Agent）";
+  if (inReplyTo) {
+    // 「回复到了」与「有人派活」是两种处境。说清楚它，模型才不会把
+    // 一句确认当成新任务 —— 那正是互相客套的起点。
+    return `你上一封信的**回复**到了${who}。这不是新任务。`;
+  }
+  if (catchup) {
+    return `你收到一封新邮件${who}。说明：这是插件离线期间积压的邮件，现在补投给你。`;
+  }
+  if (reused) {
+    return `本会话收到一封新邮件${who}。`;
+  }
+  return `你收到一封新邮件${who}。`;
+}

plugins/opencode-mail-bridge/test/relay-policy.test.mjs

@@ -0,0 +1,131 @@
+/**
+ * 自动转发适用范围的判定（lib/relay-policy.js）。
+ *
+ * 三个函数是同一件事的三个出口，必须一起看：
+ *   - autoRelayDecision  插件该不该替模型把结论发出去
+ *   - replyInstruction   提示词里怎么跟模型说这件事
+ *   - inboundHeadline    进来的这封是新活、是回复、还是补投
+ *
+ * 分开写必然分叉，而分叉的代价是模型被骗：以为插件会替它回信，于是把话说完
+ * 就停手，那封信却永远不会发出去。所以这里逐条钉住它们的一致性。
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  addrName,
+  autoRelayDecision,
+  replyInstruction,
+  inboundHeadline,
+} from '../lib/relay-policy.js';
+
+// ─── addrName ───
+
+test('addrName 取三维地址的名字段', () => {
+  assert.equal(addrName('pi@/home/program/agentmail.某别名'), 'pi');
+  assert.equal(addrName('jianf'), 'jianf');
+  assert.equal(addrName('  dsh@/x  '), 'dsh');
+  assert.equal(addrName(''), '');
+  assert.equal(addrName(undefined), '');
+});
+
+// ─── autoRelayDecision ───
+
+test('人类来信 → 自动转发', () => {
+  const d = autoRelayDecision({ fromHuman: true, replyTo: 'jianf' });
+  assert.equal(d.relay, true);
+});
+
+test('Agent 来信 → 不自动转发', () => {
+  const d = autoRelayDecision({ fromHuman: false, replyTo: 'dsh' });
+  assert.equal(d.relay, false,
+    'Agent 间通信必须由模型主动 send_mail —— 两边都自动回会无休止互相唤醒');
+  assert.match(d.reason, /dsh/, '日志要说清是谁');
+  assert.match(d.reason, /Agent/);
+});
+
+test('不知道回给谁 → 不转发，且理由与「对方是 Agent」区分得开', () => {
+  const d = autoRelayDecision({ fromHuman: true, replyTo: '' });
+  assert.equal(d.relay, false);
+  assert.match(d.reason, /不知道回给谁/,
+    '「本轮没有回信」有三种原因，日志里必须能分辨');
+});
+
+test('replyTo 带三维地址时也能认出 Agent 名', () => {
+  const d = autoRelayDecision({ fromHuman: false, replyTo: 'opencode@/home/x.别名' });
+  assert.equal(d.relay, false);
+  assert.match(d.reason, /opencode/);
+});
+
+test('缺省参数不抛错（畸形事件不该弄死投递）', () => {
+  assert.equal(autoRelayDecision().relay, false);
+  assert.equal(autoRelayDecision({}).relay, false);
+});
+
+// ─── replyInstruction 与 autoRelayDecision 的一致性 ───
+
+test('人类来信的提示词承诺「插件会替你发」，且这与决策一致', () => {
+  const lines = replyInstruction({ fromHuman: true });
+  const text = lines.join('\n');
+  assert.match(text, /回信不用你自己发/);
+  assert.equal(autoRelayDecision({ fromHuman: true, replyTo: 'jianf' }).relay, true,
+    '承诺了就必须真的做');
+});
+
+test('Agent 来信的提示词必须明说「插件不会替你回信」', () => {
+  const text = replyInstruction({ fromHuman: false }).join('\n');
+  assert.match(text, /不会替你回信/);
+  assert.match(text, /send_mail/, '必须给出唯一可行的做法');
+  assert.doesNotMatch(text, /回信不用你自己发/,
+    '这句话在 Agent → Agent 时是假的 —— 说了它模型就会把话说完然后停手');
+});
+
+test('Agent 来信的提示词要劝阻纯客套', () => {
+  const text = replyInstruction({ fromHuman: false }).join('\n');
+  assert.match(text, /收到|确认/, '要点名那种没有信息量的回复');
+  assert.match(text, /互相客套|无休止/, '要说清后果，否则模型不知道为什么被劝阻');
+});
+
+test('Agent 来信时把回信地址带进提示词（有就带）', () => {
+  const withAddr = replyInstruction({ fromHuman: false, replyAddress: 'dsh@/x.别名' }).join('\n');
+  assert.match(withAddr, /dsh@\/x\.别名/,
+    '要它自己发信却不给地址，它会拼一个 .new 出来 —— 那会静默开新会话');
+  const without = replyInstruction({ fromHuman: false }).join('\n');
+  assert.doesNotMatch(without, /（回信地址：）/, '没有地址时不该留一个空括号');
+});
+
+// ─── inboundHeadline ───
+
+test('回复到了 → 明说「这不是新任务」', () => {
+  const h = inboundHeadline({ inReplyTo: 'm-1', fromHuman: false });
+  assert.match(h, /回复/);
+  assert.match(h, /不是新任务/,
+    '把回复当新任务处理正是互相客套的起点');
+});
+
+test('回复的标题优先于续谈/补投标记', () => {
+  const h = inboundHeadline({ inReplyTo: 'm-1', fromHuman: true, reused: true, catchup: true });
+  assert.match(h, /回复/, 'in_reply_to 是最强信号');
+});
+
+test('Agent 来信在标题里就标出来', () => {
+  assert.match(inboundHeadline({ fromHuman: false }), /Agent/);
+  assert.doesNotMatch(inboundHeadline({ fromHuman: true }), /Agent/,
+    '人类来信不该带这个括号 —— 那是噪音');
+});
+
+test('补投要说明，否则模型按「刚到的」语气回', () => {
+  const h = inboundHeadline({ fromHuman: true, catchup: true });
+  assert.match(h, /积压|补投/);
+});
+
+test('续谈与新会话的措辞不同', () => {
+  assert.match(inboundHeadline({ fromHuman: true, reused: true }), /本会话/);
+  assert.match(inboundHeadline({ fromHuman: true, reused: false }), /你收到/);
+});
+
+test('缺省参数不抛错', () => {
+  assert.equal(typeof inboundHeadline(), 'string');
+  assert.equal(typeof inboundHeadline({}), 'string');
+});