feat: agent 邮件寻址能力全面补齐 + .new 别名替换

## 别名替换（让 .new 邮件可寻址）

repo/autoalias.go: AutoAliasFor + EnsureSessionAlias
- .new 建完会话立刻给别名（形如 dsh-重构导入路径）
- 名字与主题都要：只用主题跨 Agent 撞名，只用名字看不出聊什么
- sanitizeAliasPart 只留 unicode.IsLetter/IsDigit，其余折 -
- 撞名追加 -2/-3，全占用退 session-<uuid前8位>
- 不复用 SyncSessionAlias：那个假定已存在且跳过 manual
- 条件写入 WHERE alias IS NULL OR ''，并发安全
- resolveTarget 的 .new 与默认会话两条路径都调

notifyRecipients 加三个字段（每个收件方拿到自己那个地址的版本）：
- session_alias / reply_address / self_address
- 别名为空时退回省略 session 位，绝不写 new

FormatAddress(name,path,session) 空 path 也必须留 @ 与 .

## Agent 侧寻址发现（五个只读端点）

handler/agent_discovery.go:
- /agent/contacts + /agent/contacts/suggest（三段式补全）
- /agent/mail/{id} + /agent/mail/{id}/thread
- /agent/sessions/{id}/participants
- 不复用人类路由：scope 不同、审计需求不同
- 一律只读：归档/改名/权限决策仍只有人能做

repo/participants.go: SessionParticipants 逐封扫 from/to/cc
- Roles 用集合、MailCount 只数发信（0=还没开口的人）
- 发件人 path 不取 from_workspace（那列存的是 Agent 名）

repo.SuggestPaths 重写：mails.to_workspace（按 MAX(created_at) 倒序）
+ agents.workspaces 并集。原只读 workspaces，官方插件传 [] 永远空

## 共用模块（三插件逐字节相同）

lib/addressing.js: formatAddress/roleOf/replyAddressFor/selfAddressFor/participantsOfMail
lib/discovery.js: renderNameSuggestions/renderPathSuggestions/renderSessionSuggestions/
                  renderParticipants/renderContacts/renderThread

lib/inbox-format.js: renderMail 新增收件人/身份/可投递地址三段
  - selfName 参数（兼容旧调用不传的情况）

check-shared-libs.sh 纳入 addressing + discovery

## 插件侧

opencode: suggest_address + list_contacts + session_participants + read_thread + read_mail
dsh: 同上 + forward_mail（此前只有 opencode 有）+ upload_attachment 改真 multipart
pi: 同上（createMailTools 加 agentName 参数）

dsh: ctx.agents.create id collision 改为 readSession 探测后 resume
dsh: 关键路径日志改 console.error（ctx.logger 不进 journalctl）

## 测试

repo: autoalias_test.go 11 + participants_test.go 7 = 18 例
plugins: addressing.test 17 + discovery.test 23 + inbox-format.test 31 = 71 例
go test ./... + npm test（opencode 155 + dsh 173 + pi 199）全绿
端到端验证：admin 发 dsh@....new 抄送 opencode@....new
  → dsh 用 session_participants 取到地址 → send_mail 给 opencode
  → 地址取自工具返回值（.crisp-planet），未手工拼写

plugins/opencode-mail-bridge/test/addressing.test.mjs

@@ -0,0 +1,145 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  formatAddress,
+  roleOf,
+  replyAddressFor,
+  selfAddressFor,
+  participantsOfMail,
+} from '../lib/addressing.js';
+
+// 地址拼错不会报错，只会投到别处 —— 所以这一组测试全部落在
+// 「拼出来的东西还能不能被正确解析回三段」上。
+
+test('formatAddress: 空 path 仍保留 @ 与 .', () => {
+  // 生产事故：朴素拼接得到 admin.silent-harbor，没有 @，
+  // 整串被 ParseAddress 当成名字，session 位静默丢失。
+  assert.equal(formatAddress('admin', '', 'silent-harbor'), 'admin@.silent-harbor');
+});
+
+test('formatAddress: 省略 session 位', () => {
+  assert.equal(formatAddress('dsh', '/home/program/agentmail', ''), 'dsh@/home/program/agentmail');
+  // 名字与 path 都有但都不带会话 → 默认会话语义
+  assert.equal(formatAddress('dsh', '', ''), 'dsh');
+});
+
+test('formatAddress: path 含 . 与 / 时仍按最后一个 . 切', () => {
+  // path 里允许 . 与 /，切分靠最后一个 . —— 拼出来的必须满足这个约定
+  const addr = formatAddress('bot', '/srv/app.v2', 'fix-leak');
+  assert.equal(addr, 'bot@/srv/app.v2.fix-leak');
+  assert.equal(addr.slice(addr.lastIndexOf('.') + 1), 'fix-leak');
+});
+
+test('formatAddress: 名字为空返回空串而不是残缺地址', () => {
+  // 返回 "@/path.alias" 会被投递端当成缺名字报错，
+  // 但那是在很后面才发现；这里直接给空串让调用方立刻看出没法拼。
+  assert.equal(formatAddress('', '/p', 'a'), '');
+  assert.equal(formatAddress(null, '/p', 'a'), '');
+});
+
+test('formatAddress: 去掉首尾空白', () => {
+  assert.equal(formatAddress(' dsh ', ' /home ', ' alias '), 'dsh@/home.alias');
+});
+
+const ccMail = {
+  from_name: 'admin',
+  to_name: 'dsh',
+  to_workspace: '/home/program/llmsproxy',
+  cc_list: [{ name: 'opencode', path: '/home', session: 'new', raw: 'opencode@/home.new' }],
+  session_alias: 'silent-harbor',
+};
+
+test('roleOf: 区分主收件人与抄送方', () => {
+  // 被抄送方与主收件人职责不同：线上那封联调邮件里 dsh 负责汇报、
+  // opencode 只提供信息。不区分身份两方都会以为自己是负责人。
+  assert.equal(roleOf(ccMail, 'dsh'), 'to');
+  assert.equal(roleOf(ccMail, 'opencode'), 'cc');
+  assert.equal(roleOf(ccMail, 'someone-else'), 'unknown');
+});
+
+test('roleOf: 名字为空时不猜', () => {
+  assert.equal(roleOf(ccMail, ''), 'unknown');
+  assert.equal(roleOf(ccMail, undefined), 'unknown');
+});
+
+test('replyAddressFor: 用会话别名而非原地址的 .new', () => {
+  // 关键回归：把 .new 原样当回信地址会再建一条平行会话。
+  const addr = replyAddressFor(ccMail);
+  assert.equal(addr, 'admin@.silent-harbor');
+  assert.ok(!addr.endsWith('.new'), '回信地址不得以 .new 结尾');
+});
+
+test('replyAddressFor: 发件人一侧不带 path', () => {
+  // Agent 回信时 from_workspace 存的是 Agent 名而不是路径，
+  // 拿它拼会得到 dsh@dsh.alias —— 投不出去。
+  const mail = { from_name: 'dsh', from_workspace: 'dsh', session_alias: 'x' };
+  assert.equal(replyAddressFor(mail), 'dsh@.x');
+});
+
+test('replyAddressFor: 无别名时退回默认会话形式', () => {
+  const mail = { from_name: 'admin', session_alias: '' };
+  const addr = replyAddressFor(mail);
+  assert.equal(addr, 'admin');
+  // 调用方靠有没有 . 判断这是不是「投回同一条会话」
+  assert.ok(!addr.includes('.'), '默认会话形式不含 session 位');
+});
+
+test('selfAddressFor: 抄送方取自己那个地址的 path', () => {
+  // to_workspace 是主收件人的工作目录。抄送方拿它当自己的 path，
+  // 「我是谁」这句话就指向了别人的目录。
+  assert.equal(selfAddressFor(ccMail, 'opencode'), 'opencode@/home.silent-harbor');
+  assert.equal(selfAddressFor(ccMail, 'dsh'), 'dsh@/home/program/llmsproxy.silent-harbor');
+});
+
+test('participantsOfMail: 抄送方的 path 是自己那个', () => {
+  const parts = participantsOfMail(ccMail, 'dsh');
+  const byName = Object.fromEntries(parts.map(p => [p.name, p]));
+
+  assert.equal(byName.opencode.path, '/home');
+  assert.equal(byName.opencode.address, 'opencode@/home.silent-harbor');
+  assert.equal(byName.dsh.path, '/home/program/llmsproxy');
+  // 发件人 path 留空，理由同 replyAddressFor
+  assert.equal(byName.admin.address, 'admin@.silent-harbor');
+});
+
+test('participantsOfMail: 地址一律用会话别名，不带 .new', () => {
+  // cc_list 里原本记的是 opencode@/home.new。参与方地址必须换成别名，
+  // 否则「回给抄收方」这个动作每次都会新开会话。
+  for (const p of participantsOfMail(ccMail, 'dsh')) {
+    assert.ok(!p.address.endsWith('.new'), `${p.name} 的地址仍是 .new: ${p.address}`);
+  }
+});
+
+test('participantsOfMail: 自己被标记而不是被剔除', () => {
+  // 剔掉的话模型无法确认这封信是不是也发给了自己，
+  // 也就无法判断自己该不该回。
+  const parts = participantsOfMail(ccMail, 'opencode');
+  const me = parts.find(p => p.name === 'opencode');
+  assert.ok(me, '自己应出现在参与方列表里');
+  assert.equal(me.is_self, true);
+  assert.equal(parts.filter(p => p.is_self).length, 1);
+});
+
+test('participantsOfMail: 角色齐全且顺序为 from → to → cc', () => {
+  // 主收件人稳定排在抄送方之前，模型据此判断谁是负责人、谁是配合方
+  const parts = participantsOfMail(ccMail, 'dsh');
+  assert.deepEqual(parts.map(p => p.role), ['from', 'to', 'cc']);
+});
+
+test('participantsOfMail: 无抄送时只有两方', () => {
+  const mail = { from_name: 'admin', to_name: 'dsh', to_workspace: '/w', session_alias: 'a' };
+  const parts = participantsOfMail(mail, 'dsh');
+  assert.equal(parts.length, 2);
+});
+
+test('participantsOfMail: 跳过空名字条目', () => {
+  // cc_list 里出现空对象（历史数据或解析残缺）不该产出一个 address 为空的参与方
+  const mail = {
+    from_name: 'admin', to_name: 'dsh', to_workspace: '/w',
+    cc_list: [{ name: '', path: '/x' }, {}],
+    session_alias: 'a',
+  };
+  const parts = participantsOfMail(mail, 'dsh');
+  assert.equal(parts.length, 2);
+  for (const p of parts) assert.notEqual(p.address, '');
+});

plugins/opencode-mail-bridge/test/discovery.test.mjs

@@ -0,0 +1,218 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  renderNameSuggestions,
+  renderPathSuggestions,
+  renderSessionSuggestions,
+  renderParticipants,
+  renderContacts,
+  renderThread,
+} from '../lib/discovery.js';
+
+// 这一组渲染的唯一目的是让模型**不要自己拼地址**。
+// 所以断言集中在两点：给出的地址能原样使用；以及模型知道下一步该查什么。
+
+test('renderNameSuggestions 只给名字并指向下一步', () => {
+  // 此时还不知道 path 与 session，硬拼裸名字地址会投到「默认会话」——
+  // 那不一定是调用方想要的那条。
+  const got = renderNameSuggestions(['opencode', 'admin']);
+  assert.match(got, /opencode/);
+  assert.match(got, /admin/);
+  assert.match(got, /suggest_address/, '要告诉模型下一步查什么');
+});
+
+test('renderNameSuggestions 空列表给明确文案', () => {
+  assert.match(renderNameSuggestions([]), /没有可投递的收件人/);
+  assert.match(renderNameSuggestions(undefined), /没有可投递的收件人/);
+});
+
+test('renderPathSuggestions 空列表要说清「仍然能发」', () => {
+  // 不解释的话模型会卡在这一步，或者编一个路径出来。
+  const got = renderPathSuggestions([], 'admin');
+  assert.match(got, /可以留空/);
+  assert.match(got, /admin/);
+});
+
+test('renderPathSuggestions 列出目录并指向下一步', () => {
+  const got = renderPathSuggestions(['/home', '/home/program/agentmail'], 'opencode');
+  assert.match(got, /\/home\/program\/agentmail/);
+  assert.match(got, /最近使用/);
+  assert.match(got, /suggest_address\(name="opencode", path="/);
+});
+
+const sessionData = {
+  kind: 'session',
+  suggestions: ['silent-harbor', 'happy-tiger', 'new'],
+  addresses: [
+    'opencode@/home.silent-harbor',
+    'opencode@/home.happy-tiger',
+    'opencode@/home.new',
+  ],
+  candidates: [
+    { alias: 'silent-harbor', title: '联调 llmsproxy', source: 'mail', unread: 2 },
+    { alias: 'happy-tiger', title: '补投验证', source: 'mail', unread: 0 },
+    { alias: 'new', title: '新建会话', source: 'new' },
+  ],
+};
+
+test('renderSessionSuggestions 用服务端拼好的完整地址', () => {
+  // 插件自己拼过一次，拼错了（空 path 时漏掉 @）。addresses 与 suggestions
+  // 同序由服务端保证，直接用。
+  const got = renderSessionSuggestions(sessionData, 'opencode', '/home');
+  assert.match(got, /opencode@\/home\.silent-harbor/);
+  assert.match(got, /opencode@\/home\.happy-tiger/);
+  assert.match(got, /原样填进 send_mail 的 to/);
+});
+
+test('renderSessionSuggestions 带出标题与未读数', () => {
+  const got = renderSessionSuggestions(sessionData, 'opencode', '/home');
+  assert.match(got, /联调 llmsproxy/);
+  assert.match(got, /2 封未读/);
+});
+
+test('不变量：new 不与已存在会话混列，且带警告', () => {
+  // new 排在前面会让模型在想续谈时顺手开出一条新线索 —— 生产上已经发生过。
+  const got = renderSessionSuggestions(sessionData, 'opencode', '/home');
+  const lines = got.split('\n');
+  const newLineIdx = lines.findIndex(l => l.includes('.new'));
+  const harborIdx = lines.findIndex(l => l.includes('silent-harbor'));
+  assert.ok(harborIdx >= 0 && newLineIdx > harborIdx, 'new 必须排在已存在会话之后');
+  assert.match(got, /新\*\*线索|新\*\*/, 'new 要带「这是开新线索」的提示');
+});
+
+test('renderSessionSuggestions 无已存在会话时引导命名', () => {
+  // 这是关键引导：开新会话时传 session_alias，之后才能按名字续谈。
+  // 不传的话服务端会自动命名，但模型不知道那个名字。
+  const got = renderSessionSuggestions(
+    { suggestions: ['new'], addresses: ['dsh@/tmp.new'], candidates: [{ alias: 'new', source: 'new' }] },
+    'dsh', '/tmp',
+  );
+  assert.match(got, /还没有可续谈的会话/);
+  assert.match(got, /session_alias/);
+});
+
+const participantData = {
+  session_id: 'f3d824ce',
+  session_alias: 'silent-harbor',
+  participants: [
+    { name: 'admin', path: '', roles: ['from'], is_self: false, mail_count: 1, address: 'admin@.silent-harbor' },
+    { name: 'dsh', path: '/home/program/llmsproxy', roles: ['to'], is_self: true, mail_count: 0, address: 'dsh@/home/program/llmsproxy.silent-harbor' },
+    { name: 'opencode', path: '/home', roles: ['cc'], is_self: false, mail_count: 0, address: 'opencode@/home.silent-harbor' },
+  ],
+};
+
+test('renderParticipants 给出每个参与方的地址', () => {
+  const got = renderParticipants(participantData);
+  assert.match(got, /opencode@\/home\.silent-harbor/);
+  assert.match(got, /admin@\.silent-harbor/);
+  assert.match(got, /原样填进 send_mail 的 to/);
+});
+
+test('不变量：标出「尚未回应」的人', () => {
+  // mail_count 为 0 就是还没开口的人。服务端只数「作为发件人」的邮件，
+  // 正是为了让这个判断成立。
+  const got = renderParticipants(participantData);
+  const line = got.split('\n').find(l => l.includes('opencode'));
+  assert.match(line, /尚未回应/);
+  // 自己不该被标「尚未回应」—— 自己正在处理这封
+  const selfLine = got.split('\n').find(l => l.includes('dsh'));
+  assert.ok(!selfLine.includes('尚未回应'));
+  assert.match(selfLine, /就是你/);
+});
+
+test('renderParticipants 用中文角色标签', () => {
+  // 模型读到「抄送方」比读到 cc 更容易判对分工。
+  const got = renderParticipants(participantData);
+  assert.match(got, /抄送方/);
+  assert.match(got, /发件人/);
+});
+
+test('renderParticipants 无地址时说明原因', () => {
+  const got = renderParticipants({
+    session_alias: '',
+    participants: [{ name: 'x', roles: ['to'], mail_count: 0, address: '' }],
+  });
+  assert.match(got, /尚未命名/);
+});
+
+test('renderParticipants 空会话不崩', () => {
+  assert.match(renderParticipants({ participants: [] }), /还没有参与方/);
+  assert.match(renderParticipants({}), /还没有参与方/);
+});
+
+test('renderContacts 未读优先排序', () => {
+  // 模型问「我还有什么没处理」时，有未读的那些才是答案。
+  const got = renderContacts({
+    contacts: [
+      { address: 'a@.x', unread_count: 0, last_activity: '2026-09-03T02:00:00Z' },
+      { address: 'b@.y', unread_count: 3, last_activity: '2026-09-01T00:00:00Z' },
+    ],
+  });
+  const lines = got.split('\n').filter(l => l.startsWith('- '));
+  assert.match(lines[0], /b@\.y/, '有未读的应排在最前');
+  assert.match(lines[0], /3 封未读/);
+});
+
+test('renderContacts 带出剩余预算', () => {
+  const got = renderContacts({
+    contacts: [{ address: 'a@.x', unread_count: 0, max_rounds: 20, used_rounds: 17 }],
+  });
+  assert.match(got, /剩 3\/20 个来回/);
+});
+
+test('renderContacts 未命名会话说明只能 reply_to', () => {
+  const got = renderContacts({ contacts: [{ address: '', unread_count: 1 }] });
+  assert.match(got, /reply_to/);
+});
+
+test('renderContacts 空列表', () => {
+  assert.match(renderContacts({ contacts: [] }), /还没有任何往来会话/);
+});
+
+const threadData = {
+  anchor_mail_id: 'm-2',
+  total: 3,
+  hidden: 1,
+  nodes: [
+    { mail_id: 'm-1', from_name: 'admin', to_name: 'dsh', subject: '抄收联调', depth: 0 },
+    { mail_id: 'm-2', from_name: 'dsh', to_name: 'opencode', subject: '[联调] 请提供部署现状', depth: 1 },
+    { mail_id: 'm-3', from_name: 'opencode', to_name: 'dsh', subject: 'Re: 联调', depth: 2, detached: true, parent_hidden: true },
+  ],
+};
+
+test('renderThread 用缩进表示层级', () => {
+  const got = renderThread(threadData, 'dsh');
+  const lines = got.split('\n');
+  const l1 = lines.find(l => l.includes('m-1'));
+  const l2 = lines.find(l => l.includes('m-2'));
+  assert.ok(l2.indexOf('- ') > l1.indexOf('- '), '子节点应更深缩进');
+});
+
+test('不变量：detached 必须标出来', () => {
+  // 不标的话模型会以为这是一条独立线索，而它其实挂在一封看不到的邮件下面。
+  const got = renderThread(threadData, 'dsh');
+  const line = got.split('\n').find(l => l.includes('m-3'));
+  assert.match(line, /父邮件无权查看/);
+});
+
+test('renderThread 标出自己发的与当前这封', () => {
+  const got = renderThread(threadData, 'dsh');
+  assert.match(got.split('\n').find(l => l.includes('m-2')), /你发的/);
+  assert.match(got.split('\n').find(l => l.includes('m-2')), /当前这封/);
+});
+
+test('renderThread 报告不可见数量', () => {
+  // 「共 3 封」与实际列出 3 条一致，但另有 1 封无权查看 ——
+  // 不说的话模型会以为自己看到了全貌。
+  assert.match(renderThread(threadData), /另有 1 封无权查看/);
+});
+
+test('renderThread 有更多时给出 offset', () => {
+  const got = renderThread({ ...threadData, has_more: true, next_offset: 60 });
+  assert.match(got, /offset=60/);
+});
+
+test('renderThread 空线索不崩', () => {
+  assert.match(renderThread({ nodes: [] }), /没有可见的邮件/);
+  assert.match(renderThread({}), /没有可见的邮件/);
+});

plugins/opencode-mail-bridge/test/inbox-format.test.mjs

@@ -117,6 +117,96 @@ test('附件字段不是数组时忽略', () => {
   assert.ok(!got.includes('抄送'));
 });
 
+// ─── 收件人与身份（只有知道自己是谁才能判定）───
+
+test('不变量：收件人要显示出来', () => {
+  // 不显示的后果：被抄送方不知道主收件人是谁，无法向对方转达或汇报。
+  // 线上那封联调邮件要求「由收件人汇报」，而抄送方看不到收件人叫什么。
+  const got = renderMail(mail({ to_name: 'dsh', to_workspace: '/home/program/llmsproxy' }));
+  assert.match(got, /收件人: dsh@\/home\/program\/llmsproxy/);
+});
+
+test('收件人无工作目录时只显名字', () => {
+  const got = renderMail(mail({ to_name: 'admin', to_workspace: '' }));
+  assert.match(got, /收件人: admin$/m);
+});
+
+test('不传 selfName 时不出现身份行（兼容旧调用）', () => {
+  const got = renderMail(mail({ to_name: 'dsh' }));
+  assert.ok(!got.includes('你的身份'));
+});
+
+test('不变量：区分收件人与抄送方身份', () => {
+  // 两者职责不同。不区分的话两方都会以为自己是负责人，
+  // 或者都以为自己只是旁观者。
+  const m = mail({
+    to_name: 'dsh',
+    to_workspace: '/home/program/llmsproxy',
+    cc_list: [{ name: 'opencode', path: '/home', raw: 'opencode@/home.new' }],
+  });
+  assert.match(renderMail(m, 200, 'dsh'), /你的身份: 收件人/);
+  assert.match(renderMail(m, 200, 'opencode'), /你的身份: 抄送方/);
+  // 不相关的名字不编造身份
+  assert.ok(!renderMail(m, 200, 'someone').includes('你的身份'));
+});
+
+// ─── 可投递地址（「精准发信」的关键）───
+
+const joint = () => mail({
+  mail_id: 'm-7',
+  from_name: 'admin',
+  to_name: 'dsh',
+  to_workspace: '/home/program/llmsproxy',
+  cc_list: [{ name: 'opencode', path: '/home', session: 'new', raw: 'opencode@/home.new' }],
+  session_alias: 'silent-harbor',
+});
+
+test('不变量：给出每个参与方的可投递地址', () => {
+  // 之前模型只能从抄送行里拄一个 `opencode@/home.new`，
+  // 而那个地址回过去只会再建一条平行会话。
+  const got = renderMail(joint(), 200, 'dsh');
+  assert.match(got, /可投递地址/);
+  assert.match(got, /opencode@\/home\.silent-harbor（抄送方）/);
+  assert.match(got, /admin@\.silent-harbor（发件人）/);
+});
+
+test('不变量：可投递地址里绝不出现 .new', () => {
+  // 这是本轮修的根因的直接回归：`.new` 是一次性动作，
+  // 把它当回信地址会让双方各说各话。
+  const got = renderMail(joint(), 200, 'dsh');
+  const line = got.split('\n').find(l => l.startsWith('可投递地址'));
+  assert.ok(line, '应有可投递地址行');
+  assert.ok(!line.includes('.new'), `地址行仍含 .new: ${line}`);
+});
+
+test('可投递地址不列自己', () => {
+  const got = renderMail(joint(), 200, 'dsh');
+  const line = got.split('\n').find(l => l.startsWith('可投递地址'));
+  assert.ok(!line.includes('dsh@'), `不该把自己当成收件人选项: ${line}`);
+});
+
+test('同时给出 reply_to 这条更稳的路', () => {
+  // 地址可能拼错，reply_to 不会 —— 两条路都告诉模型。
+  const got = renderMail(joint(), 200, 'dsh');
+  assert.match(got, /reply_to=m-7/);
+});
+
+test('无会话别名时不给地址（宁可不给不可给错）', () => {
+  // 别名为空时拼不出「投回这条会话」的地址。给一个看着能用
+  // 实际指向默认会话的地址，比不给危险。
+  const got = renderMail(mail({
+    to_name: 'dsh', session_alias: '',
+    cc_list: [{ name: 'opencode', path: '/home' }],
+  }), 200, 'dsh');
+  assert.ok(!got.includes('可投递地址'));
+});
+
+test('renderInbox 透传 selfName', () => {
+  const got = renderInbox([joint()], 200, 'opencode');
+  assert.match(got, /你的身份: 抄送方/);
+  assert.match(got, /dsh@\/home\/program\/llmsproxy\.silent-harbor（收件人）/);
+});
+
 // ─── renderInbox ───
 
 test('renderInbox 空收件箱给明确文案', () => {

plugins/opencode-mail-bridge/test/model-scope.test.mjs

@@ -12,6 +12,7 @@ import assert from 'node:assert/strict';
 import {
   snapshotOpencodeModels,
   snapshotDshModels,
+  snapshotPiModels,
   modelAttemptOrder,
   renderFailureReport,
   MAX_CATALOG,
@@ -106,6 +107,46 @@ test('目录截断到 MAX_CATALOG', () => {
   assert.equal(snapshotDshModels(many).length, MAX_CATALOG);
 });
 
+// ─── pi 目录 ───
+
+test('pi 目录用 provider + id', () => {
+  const got = snapshotPiModels([
+    { provider: 'llmsproxy', id: 'AUTO', name: 'AUTO' },
+    { provider: 'anthropic', id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6' },
+  ]);
+  assert.equal(got.length, 2);
+  assert.deepEqual(got[1], {
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-6',
+    display_name: 'Claude Sonnet 4.6',
+  });
+});
+
+test('pi 目录跳过缺 provider 或 id 的条目', () => {
+  const got = snapshotPiModels([
+    { provider: '', id: 'x' },
+    { provider: 'p' },
+    { provider: 'p', id: 'ok' },
+  ]);
+  assert.equal(got.length, 1);
+  assert.equal(got[0].model, 'ok');
+});
+
+test('pi 目录容错：非数组不崩', () => {
+  assert.deepEqual(snapshotPiModels(undefined), []);
+  assert.deepEqual(snapshotPiModels(null), []);
+  assert.deepEqual(snapshotPiModels('oops'), []);
+});
+
+test('pi 目录同样受 MAX_CATALOG 截断', () => {
+  // 本机 pi 的完整目录有 1221 个模型（getModels），远超上限。
+  // 桥实际上报的是 getAvailable() 的结果（只有带凭证的），但截断仍要生效。
+  const many = Array.from({ length: MAX_CATALOG + 50 }, (_, i) => ({
+    provider: 'p', id: `m${i}`, name: `M${i}`,
+  }));
+  assert.equal(snapshotPiModels(many).length, MAX_CATALOG);
+});
+
 // ─── modelAttemptOrder ───
 
 test('管理员划定范围时按 rank 顺序尝试', () => {

plugins/opencode-mail-bridge/test/session-snapshot.test.mjs

@@ -12,6 +12,8 @@ import assert from 'node:assert/strict';
 import {
   snapshotOpencodeSessions,
   snapshotDshSessions,
+  snapshotPiSessions,
+  isUnusableName,
   slugFromTitle,
   MAX_REPORTED,
 } from '../lib/session-snapshot.js';
@@ -226,3 +228,99 @@ test('不同标题不受去重影响', () => {
   ]);
   assert.equal(got.length, 2);
 });
+
+// ─── pi：名字来自会话文件的 session_info ───
+
+const piSession = (over = {}) => ({
+  id: '01a064cc-df57-7b2d-bebb-736776105485',
+  cwd: '/home/program/agentmail',
+  name: '重构导入路径',
+  messageCount: 6,
+  created: new Date(1788300000000),
+  modified: new Date(1788344476744),
+  ...over,
+});
+
+test('pi 快照取 cwd 与 session_info 名字', () => {
+  const [got] = snapshotPiSessions([piSession()]);
+  assert.equal(got.workspace, '/home/program/agentmail');
+  assert.equal(got.title, '重构导入路径');
+  assert.equal(got.slug, '重构导入路径');
+  assert.equal(got.platform_id, '01a064cc-df57-7b2d-bebb-736776105485');
+});
+
+test('不变量：pi 无名会话不上报', () => {
+  // pi 的列表在无名时显示首条消息，而邮件驱动会话的首条消息是桥自己拼的提示词
+  // （「你收到一封新邮件（AgentMail）…」）—— 拿它当别名毫无区分度，且条条撞名。
+  const got = snapshotPiSessions([
+    piSession({ id: 'named', name: '有名字' }),
+    piSession({ id: 'anon', name: undefined }),
+    piSession({ id: 'blank', name: '' }),
+  ]);
+  assert.deepEqual(got.map(s => s.platform_id), ['named']);
+});
+
+test('不变量：pi 老会话的空 cwd 照实上报', () => {
+  // SessionInfo 的注释写明老会话 cwd 是空串。拿桥自己的 cwd 冒充会让
+  // 那条会话在补全里挂到一个它其实不属于的工作区下。
+  const [got] = snapshotPiSessions([piSession({ cwd: '' })]);
+  assert.equal(got.workspace, '');
+});
+
+test('不变量：pi 的 updated_at 取 modified（文件 mtime）', () => {
+  const [got] = snapshotPiSessions([piSession()]);
+  assert.equal(got.updated_at, new Date(1788344476744).toISOString());
+});
+
+test('pi 快照按最近活跃排序并对撞名 slug 去重', () => {
+  const got = snapshotPiSessions([
+    piSession({ id: 'old', name: '同一个标题', modified: new Date(1000) }),
+    piSession({ id: 'new', name: '同一个标题', modified: new Date(9000) }),
+  ]);
+  assert.equal(got.length, 1);
+  assert.equal(got[0].platform_id, 'new');
+});
+
+test('pi 快照标记邮件驱动的会话', () => {
+  const got = snapshotPiSessions(
+    [piSession({ id: 'mail-one' }), piSession({ id: 'human', name: '人开的' })],
+    (id) => id === 'mail-one'
+  );
+  assert.equal(got.find(s => s.platform_id === 'mail-one').mail_driven, true);
+  assert.equal(got.find(s => s.platform_id === 'human').mail_driven, false);
+});
+
+// ─── isUnusableName：pi-web 标题生成器的思维链泄漏 ───
+
+test('不变量：思维链泄漏的标题判废', () => {
+  // 都是本机 ~/.pi/agent/sessions 里实测捞到的真实 session_info 名字。
+  // pi-web 的 cleanSessionName 只做「取首行 + 去引号 + 截 60 字符」，不防这个。
+  assert.equal(isUnusableName('The user is asking me to generate a title for a coding-agent'), true);
+  assert.equal(
+    isUnusableName('我们只需要生成标题，不包含其他内容。标题应反映请求内容：测试opencode的源。简短：Opencode源测试。或者更简'),
+    true
+  );
+});
+
+test('isUnusableName 放过正常标题', () => {
+  // 宁可漏判也不误判：错杀一个好名字会让那条会话失去可寻址的别名。
+  assert.equal(isUnusableName('查看Agent接入群聊'), false);
+  assert.equal(isUnusableName('你应该知道内网拓扑结构吧'), false);
+  assert.equal(isUnusableName('homeagent-gateway'), false);
+  assert.equal(isUnusableName('重构导入路径'), false);
+  assert.equal(isUnusableName('Fix flaky auth test'), false);
+});
+
+test('isUnusableName 判废空名字', () => {
+  assert.equal(isUnusableName(''), true);
+  assert.equal(isUnusableName('   '), true);
+  assert.equal(isUnusableName(undefined), true);
+});
+
+test('判废的名字不进快照', () => {
+  const got = snapshotPiSessions([
+    piSession({ id: 'leaked', name: 'The user is asking me to generate a title for a coding-agent' }),
+    piSession({ id: 'clean', name: '正常标题' }),
+  ]);
+  assert.deepEqual(got.map(s => s.platform_id), ['clean']);
+});