feat: 配额下沉到会话 + 窄屏覆盖式布局 + 工作列表卡片视图

## 配额重构：废除 Agent 终身额度

原实现在 agents 上放一个 max_rounds/used_rounds 计数器，used_rounds 单调递增、
永不重置 —— 跑满就要管理员手工重置才能再干活。那是把一次性资源模型套在长期
在线的服务上，且并行任务互相抢额度。

改为：
- 唯一被强制的预算是【会话】的往返预算（sessions.max_rounds/used_rounds），
  写信时给、对话页里随时改 —— 配额的语义是「这件事值得多少个来回」，
  那是任务的属性而不是 Agent 的属性
- agents.default_rounds 只作为「派给这个 Agent 的新任务」的默认值（默认 20）
- agents.used_rounds 降级为纯统计
- 新建会话速率限制（1h/20 条）堵住用 .new 开一串新会话绕过预算；
  人类不受限（agentLimiterKey 返回空串即不计量）

## 窄屏适配（用户反馈「窄屏基本不可用」）

原先只有三栏并排：60(导航)+320(列表)+详情，375px 屏上详情被挤到 0。

第一版做成「一次只显示一栏」，用户纠正应当是新页面覆盖老页面并带动画，
于是重做为覆盖式：
- NarrowStack：底层列表始终挂载，详情绝对定位盖在上面。两个好处 ——
  列表滚动位置与选中态天然保留；退出动画有东西可播（直接卸载再渲染另一个
  组件的话，没有任何一帧能让旧页面往右滑出去）
- 因此必须区分「逻辑上是否打开」与「是否还在 DOM 里」：关闭时先播 200ms
  滑出，动画结束才卸载
- 入场用双层 requestAnimationFrame：必须让浏览器至少绘制一帧「在右侧之外」
  的状态，否则挂载与 translate-x-0 在同一帧内完成，transition 不触发
- 窄屏专属控件用 useIsNarrow() 条件渲染而非 md:hidden —— 后者只是视觉隐藏，
  宽屏用户按 Tab 会聚焦到看不见的返回按钮
- 底部导航 + 抽屉侧栏 + env(safe-area-inset-bottom)

## 工作列表卡片视图（Phase 7.1 最后一项）

中间栏可切列表/卡片。列表答「跟谁在聊」，卡片答「在聊什么、进展如何」：
主题 + 最新一封的发件人与摘要 + 往返预算徽标。

- 两种视图共用同一份数据与同一套动作；归档确认框也共用 —— 归档是破坏性操作，
  换个视图就换套确认 UI 只会让人对「自己点了什么」更没底
- 预算徽标在「不限」时不显示（对每张卡片都成立的「0/0」是纯噪声）
- 数据一次取回，不让卡片为每条会话再打一次库

## 修掉的缺陷

- GET /me/sessions 一直 500：ListSessionsFor 的 SELECT 加了预算两列却没加进
  Scan，列数不匹配。联系人栏一条数据都拉不到，而错误只是「Failed to list sessions」
- GET /sessions/{id} 忘了填充附件：前端会话视图走的是这个端点，于是 Agent
  回信里的附件在 UI 上完全不存在（另一个端点填了但没人调用）
- 插件曾完全没在加载：为了可测在 index.js 里 export 了辅助函数与一个 Map，
  而 opencode 把入口模块的每一个导出都当成插件工厂逐个检查，多导出一个 Map
  就 "Plugin export is not a function"，插件静默失效、邮件全投不进去。
  逻辑挪到 lib/relay-dedup.js，并加断言钉住「入口只有 default 导出」
- 同一件事发两封邮件：模型带附件主动回信后，session.idle 又把它最后那段话
  自动转了一遍（生产实测 311 与 342 字节各一封）。explicitSends 记录本轮
  主动发信，自动转发据此让位；relay_key 幂等管不了这个 —— 那个键保证的是
  「同一条消息不转两次」
- SQLite 时间戳只有秒精度：同秒插入的多封邮件排序不确定（实测同秒插 5 封，
  顺序由随机 UUID 决定）。「会话里最早那封」（决定联系人身份）与「最后那封」
  （决定最新进展）都会取错。NOW() 升到微秒 + mails 的 INSERT 显式传它
  （改 schema 默认值只对新库生效，SQLite 没有 ALTER COLUMN）+ 所有
  ORDER BY created_at 补 mail_id 兜底
- fillAttachments 从逐封查询改成一次 IN(...)：原来是 N+1，200 封的会话打开
  要打 200 次库
- repo 层 5 处 rows.Next() 循环补 rows.Err()：没有它，读到一半连接断掉会
  静默返回部分结果，UI 上表现为「邮件凭空少了几封」
- go:embed 占位页改名 placeholder.html：叫 index.html 会被 Vite 产物覆盖并
  提交进去，而它引用的 assets/ 是被忽略的 —— 新克隆打开是白屏

## 回复/转发栏

- 两处都加抄送（可折叠）；原邮件带抄送时多一个「回复全部」，回填用
  cc_list[].raw 而非重拼 name@path（后者会丢掉会话段）
- 会话视图每张卡片加转发入口：转发之前只存在于单封邮件视图，而人多数时间
  待在会话视图里，等于功能在 UI 上找不到
- ReplyBar 的错误从 console.error 改为显示出来：预算耗尽、地址不存在、
  速率限制都走这条路，之前点发送毫无反应

## 测试

- repo: 列顺序（三个 SQL 分支）、卡片字段、previewRunes 边界、时间戳亚秒精度、
  批量附件查询、速率限制（80 goroutine 断言恰好 20 条通过）
- web: 窄屏布局 16 条结构性断言（覆盖而非分栏、延迟卸载、双层 rAF、
  条件渲染而非 md:hidden）
- 插件: 自动转发去重 17 条（含「入口只有 default 导出」不变量）
- install.sh 把插件测试也纳入部署前门禁

gateway/internal/handler/agents.go

@@ -111,18 +111,20 @@ func HeartbeatAgent(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// 心跳回传配额：插件据此把剩余次数注入 Agent 上下文，
-	// 让它在配额耗尽前主动发总结，而不是撞到 403 才发现。
-	quota, qErr := repo.GetQuota(r.Context(), agentName)
-	if qErr != nil {
-		// 配额读不到不影响心跳本身，降级为不限额
-		quota = repo.Quota{AgentName: agentName, Unlimited: true, Remaining: -1}
+	// 心跳回传该 Agent 的累计统计与新任务默认预算。
+	//
+	// 不再回传「剩余额度」：额度属于具体任务（会话）而不属于 Agent，
+	// 剩余往返随每次发信响应（budget_remaining）回传，在那里才有意义。
+	stats, sErr := repo.GetAgentStats(r.Context(), agentName)
+	if sErr != nil {
+		// 统计读不到不影响心跳本身
+		stats = repo.AgentStats{AgentName: agentName}
 	}
 
 	JSON(w, http.StatusOK, map[string]interface{}{
 		"status":        "ok",
 		"pending_mails": pending,
-		"quota":         quota,
+		"stats":         stats,
 	})
 }
 

gateway/internal/handler/attachments.go

@@ -356,12 +356,31 @@ func attachAll(w http.ResponseWriter, r *http.Request, mailID uuid.UUID, ids []u
 
 // fillAttachments 给邮件填充附件列表（读取单封/线程时用）。
 // 读附件失败不该让整封邮件打不开，因此吞错只留空列表。
+//
+// 一批邮件走一次查询：逐封调 ListAttachmentsFor 是 N+1，
+// 一个 200 封的会话打开一次要打 200 次库。
 func fillAttachments(r *http.Request, mails ...*models.Mail) {
+	ids := make([]uuid.UUID, 0, len(mails))
+	for _, m := range mails {
+		if m != nil {
+			ids = append(ids, m.ID)
+		}
+	}
+	if len(ids) == 0 {
+		return
+	}
+
+	byMail, err := repo.ListAttachmentsForMails(r.Context(), ids)
+	if err != nil {
+		return
+	}
 	for _, m := range mails {
 		if m == nil {
 			continue
 		}
-		if as, err := repo.ListAttachmentsFor(r.Context(), m.ID); err == nil {
+		// 没有附件的邮件保持 nil：Attachments 带 omitempty，
+		// 填空切片只会给每封邮件的 JSON 加一个 "attachments":[]
+		if as := byMail[m.ID]; len(as) > 0 {
 			m.Attachments = as
 		}
 	}

gateway/internal/handler/forward.go

@@ -123,24 +123,27 @@ func doForward(w http.ResponseWriter, r *http.Request, mailID uuid.UUID, actor,
 	subject := forwardSubject(req.Subject, src.Subject)
 
 	// 转发按目标地址寻址，不带 reply_to：它是一条新线索，不该并进原会话
-	sessionID, _, err := resolveTarget(r, to, "", actor, subject, req.SessionAlias)
+	sessionID, _, err := resolveTarget(r, to, "", actor, subject, req.SessionAlias, agentLimiterKey(isAgent, actor))
 	if err != nil {
 		writeErr(w, err, "Failed to resolve session")
 		return
 	}
 
 	if isAgent {
-		quota, qErr := repo.ConsumeQuota(r.Context(), actor)
-		if errors.Is(qErr, repo.ErrQuotaExhausted) {
+		// 转发也是一次主动发信，扣【目标会话】的往返预算。
+		// 扣目标而不是源：转发开启的是一条新线索，消耗的是新线索的额度。
+		budget, bErr := repo.ConsumeSessionBudget(r.Context(), sessionID)
+		if errors.Is(bErr, repo.ErrSessionBudgetExhausted) {
 			Error(w, http.StatusForbidden, fmt.Sprintf(
-				"发信配额已用尽（%d/%d）。请先向人类发送最终总结，或联系管理员重置配额。",
-				quota.Used, quota.Max))
+				"目标会话的往返预算已用尽（%d/%d）。请让人在对话页调高该会话的预算。",
+				budget.Used, budget.Max))
 			return
 		}
-		if qErr != nil {
-			Error(w, http.StatusInternalServerError, "Failed to check quota")
+		if bErr != nil {
+			Error(w, http.StatusInternalServerError, "Failed to check session budget")
 			return
 		}
+		repo.BumpSentCount(r.Context(), actor)
 	} else if user != nil {
 		_ = repo.SetSessionOwner(r.Context(), sessionID, user.ID)
 	}
@@ -207,26 +210,35 @@ func MeForwardMail(w http.ResponseWriter, r *http.Request) {
 	doForward(w, r, mailID, user.Username, "", false)
 }
 
-// ---------- 配额管理（管理员） ----------
+// ---------- Agent 默认预算与统计（管理员） ----------
 
 // GET /api/v1/admin/quotas
+//
+// 路径沿用 quotas（兼容已部署的前端），但语义已变：
+// 返回的是【新任务默认预算 + 累计统计】，而不是会拦请求的终身额度。
+// 真正的额度在每条会话上（GET /sessions/{id}/budget）。
 func AdminListQuotas(w http.ResponseWriter, r *http.Request) {
-	quotas, err := repo.ListQuotas(r.Context())
+	stats, err := repo.ListAgentStats(r.Context())
 	if err != nil {
-		Error(w, http.StatusInternalServerError, "Failed to list quotas")
+		Error(w, http.StatusInternalServerError, "Failed to list agent stats")
 		return
 	}
-	JSON(w, http.StatusOK, map[string]any{"quotas": quotas})
+	JSON(w, http.StatusOK, map[string]any{"quotas": stats})
 }
 
 type setQuotaRequest struct {
-	// MaxRounds 发信配额上限；0 = 不限
+	// DefaultRounds 派给该 Agent 的新任务默认多少个来回（0 = 不限）
+	DefaultRounds *int `json:"default_rounds"`
+	// MaxRounds 是 DefaultRounds 的旧字段名，保留兼容：
+	// 已部署的前端与脚本不应该因为改名就难以察觉地失效。
 	MaxRounds *int `json:"max_rounds"`
-	// Reset 为 true 时把已用次数归零
-	Reset bool `json:"reset"`
 }
 
 // PUT /api/v1/admin/quotas/{name}
+//
+// 只能改【新任务默认预算】。不再接受 reset：
+// 累计发信数是观测数据，不拦任何请求，归零它只会销毁历史。
+// 要给某个卡住的任务加额度，去那条会话的对话页改预算。
 func AdminSetQuota(w http.ResponseWriter, r *http.Request) {
 	name := strings.TrimSpace(chi.URLParam(r, "name"))
 	if name == "" {
@@ -239,26 +251,23 @@ func AdminSetQuota(w http.ResponseWriter, r *http.Request) {
 		Error(w, http.StatusBadRequest, "Invalid JSON")
 		return
 	}
-	if req.MaxRounds == nil && !req.Reset {
-		Error(w, http.StatusBadRequest, "需要 max_rounds 或 reset 之一")
+	n := req.DefaultRounds
+	if n == nil {
+		n = req.MaxRounds // 兼容旧字段名
+	}
+	if n == nil {
+		Error(w, http.StatusBadRequest, "需要 default_rounds")
+		return
+	}
+	if *n < 0 {
+		Error(w, http.StatusBadRequest, "default_rounds 不能为负")
 		return
 	}
 
-	var (
-		q   repo.Quota
-		err error
-	)
-	if req.MaxRounds != nil {
-		if q, err = repo.SetQuota(r.Context(), name, *req.MaxRounds); err != nil {
-			Error(w, http.StatusNotFound, err.Error())
-			return
-		}
+	st, err := repo.SetDefaultRounds(r.Context(), name, *n)
+	if err != nil {
+		Error(w, http.StatusNotFound, err.Error())
+		return
 	}
-	if req.Reset {
-		if q, err = repo.ResetQuota(r.Context(), name); err != nil {
-			Error(w, http.StatusNotFound, err.Error())
-			return
-		}
-	}
-	JSON(w, http.StatusOK, map[string]any{"quota": q})
+	JSON(w, http.StatusOK, map[string]any{"quota": st})
 }

gateway/internal/handler/helpers.go

@@ -39,6 +39,11 @@ func errBadRequest(msg string) error { return httpError{http.StatusBadRequest, m
 func errNotFound(msg string) error   { return httpError{http.StatusNotFound, msg} }
 func errConflict(msg string) error   { return httpError{http.StatusConflict, msg} }
 
+// errRateLimited 用于新建会话速率限制。用 429 而不是 403：
+// 前者表示「稍后再来」，后者表示「你没这个权限」——语义完全不同，
+// 客户端据此决定是重试还是放弃。
+func errRateLimited(msg string) error { return httpError{http.StatusTooManyRequests, msg} }
+
 // writeKeyErr 把 repo 层的密钥错误映射成 HTTP 响应。
 // 「已使用 / 已过期」与「无效」分开报，便于运维判断是重签还是查配置。
 func writeKeyErr(w http.ResponseWriter, err error) {
@@ -126,3 +131,12 @@ func emptySlice[T any](s []T) []T {
 	}
 	return s
 }
+
+// agentLimiterKey 把「这是不是 Agent 发起的」翻译成速率限制的键。
+// 人类返回空串 = 不限速（手工操作的频率天然受限）。
+func agentLimiterKey(isAgent bool, actor string) string {
+	if isAgent {
+		return actor
+	}
+	return ""
+}

gateway/internal/handler/mail.go

@@ -47,7 +47,11 @@ type sendMailRequest struct {
 //
 // alias 为新建会话命名（仅新建时生效），使其之后可被 name@path.<alias> 寻址。
 // reply_to 优先于地址：显式回复某封邮件时沿用该邮件的会话。
-func resolveTarget(r *http.Request, addr models.Address, replyTo, fromAgent, subject, alias string) (uuid.UUID, *uuid.UUID, error) {
+//
+// byAgent 非空时表示这是 Agent 发起的投递，新建会话要过速率限制：
+// 往返预算按会话计，Agent 用 .new 开一串会话就等于绕过预算。
+// 人类不受此限（手工点「新建邮件」的频率天然受限，加限制只会在批量派活时误伤）。
+func resolveTarget(r *http.Request, addr models.Address, replyTo, fromAgent, subject, alias string, byAgent string) (uuid.UUID, *uuid.UUID, error) {
 	if replyTo != "" {
 		replyID, err := uuid.Parse(replyTo)
 		if err != nil {
@@ -76,10 +80,22 @@ func resolveTarget(r *http.Request, addr models.Address, replyTo, fromAgent, sub
 			}
 			aliasPtr = &a
 		}
+		// Agent 主动开新线索要过速率限制
+		if ok, retry := repo.AllowNewSession(byAgent); !ok {
+			return uuid.Nil, nil, errRateLimited(fmt.Sprintf(
+				"新建会话过于频繁（1 小时内已开 %d 条）。请在已有会话里继续，或 %d 秒后再试。",
+				repo.SessionRateLimit(), retry))
+		}
 		id, err := repo.CreateSession(r.Context(), aliasPtr, fromAgent, subject)
+		if err != nil {
+			// 建失败要把名额还回去：那次新建实际上没有发生
+			repo.ReleaseNewSession(byAgent)
+		}
 		return id, nil, err
 
 	case models.SessionDefault:
+		// 默认会话「从未通信则建立」也会产生新会话，但一个 name@path 只有一条，
+		// 不构成暴开的手段，因此不计入速率限制。
 		id, err := repo.FindOrCreateDefaultSession(r.Context(), addr.Name, addr.Path, fromAgent, subject)
 		return id, nil, err
 
@@ -132,7 +148,7 @@ func SendMail(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	sessionID, parentMailID, err := resolveTarget(r, to, req.ReplyTo, agentName, req.Subject, req.SessionAlias)
+	sessionID, parentMailID, err := resolveTarget(r, to, req.ReplyTo, agentName, req.Subject, req.SessionAlias, agentName)
 	if err != nil {
 		writeErr(w, err, "Failed to resolve session")
 		return
@@ -149,7 +165,6 @@ func SendMail(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var quota repo.Quota
 	var budget repo.SessionBudget
 	if relay != "" {
 		// 先占幂等键。重复则说明这条上游消息已经转过，
@@ -167,19 +182,19 @@ func SendMail(w http.ResponseWriter, r *http.Request) {
 			Error(w, http.StatusInternalServerError, "Failed to claim relay")
 			return
 		}
-		// 仅读快照用于回传，不扣任何一层
-		quota, _ = repo.GetQuota(r.Context(), agentName)
+		// 仅读快照用于回传，不扣预算
 		budget, _ = repo.GetSessionBudget(r.Context(), sessionID)
 	} else {
-		// 两层都要过：会话预算管「这件事值得多少个来回」，
-		// Agent 全局配额管「这个 Agent 总共能发多少」。
-		// 先扣会话、后扣全局；全局拦下时把会话那次退回去 ——
-		// 那次往返实际上没有发生，不能白掉一格。
+		// 额度只看【本任务】的往返预算。
+		//
+		// 不再叠一层 Agent 终身额度：那种额度跑满后要管理员手工重置才能再干活，
+		// 而 Agent 是长期在线的。防止 Agent 用 .new 开一串新会话绕过预算，
+		// 靠的是新建会话速率限制（resolveTarget 里）。
 		budget, err = repo.ConsumeSessionBudget(r.Context(), sessionID)
 		if errors.Is(err, repo.ErrSessionBudgetExhausted) {
 			Error(w, http.StatusForbidden, fmt.Sprintf(
-				"本会话的往返预算已用尽（%d/%d）。自动转发的总结与权限询问不占预算；"+
-					"若需继续主动发信，请让人在对话页调高本会话的预算。",
+				"本任务的往返预算已用尽（%d/%d）。自动转发的总结与权限询问不占预算；"+
+					"若需继续主动发信，请让人在对话页调高本任务的预算。",
 				budget.Used, budget.Max))
 			return
 		}
@@ -187,21 +202,8 @@ func SendMail(w http.ResponseWriter, r *http.Request) {
 			Error(w, http.StatusInternalServerError, "Failed to check session budget")
 			return
 		}
-
-		quota, err = repo.ConsumeQuota(r.Context(), agentName)
-		if errors.Is(err, repo.ErrQuotaExhausted) {
-			repo.RefundSessionBudget(r.Context(), sessionID)
-			Error(w, http.StatusForbidden, fmt.Sprintf(
-				"Agent 全局发信配额已用尽（%d/%d）。插件代劳转发的权限询问与最终总结不占配额；"+
-					"若需继续主动发信请联系管理员重置配额。",
-				quota.Used, quota.Max))
-			return
-		}
-		if err != nil {
-			repo.RefundSessionBudget(r.Context(), sessionID)
-			Error(w, http.StatusInternalServerError, "Failed to check quota")
-			return
-		}
+		// 纯统计，不拦请求；写失败也不该让邮件发不出去
+		repo.BumpSentCount(r.Context(), agentName)
 	}
 
 	// Agent 可以在正文里提议改会话别名（<!-- agentmail:rename-session … -->）。
@@ -237,27 +239,22 @@ func SendMail(w http.ResponseWriter, r *http.Request) {
 
 	notifyRecipients(to, ccList, sessionID, mailID, agentName, req.Subject)
 
-	// 回传会话别名与剩余配额，让发件方知道后续用什么地址续谈、还能发几封
+	// 回传会话别名与本任务剩余往返，让发件方知道后续用什么地址续谈、还能发几封
 	resp := map[string]any{
 		"mail_id":       mailID.String(),
 		"session_id":    sessionID.String(),
 		"session_alias": repo.SessionAliasOf(r.Context(), sessionID),
 	}
-	if !quota.Unlimited {
-		resp["quota_remaining"] = quota.Remaining
-		resp["quota_used"] = quota.Used
-		resp["quota_max"] = quota.Max
-	}
-	// 会话预算是【本任务】的剩余往返，Agent 更应该看这个而不是全局配额
+	// 预算属于【本任务】，不限时不回传 —— 多给一个 -1 只会让插件去判断哪个值是哨兵
 	if !budget.Unlimited {
 		resp["budget_remaining"] = budget.Remaining
 		resp["budget_used"] = budget.Used
 		resp["budget_max"] = budget.Max
 	}
 	if relay != "" {
-		// 告知本次未扣配额，否则插件看到 quota_remaining 没变会以为数据错了
+		// 告知本次未扣预算，否则插件看到 budget_remaining 没变会以为数据错了
 		resp["relay"] = relay
-		resp["quota_charged"] = false
+		resp["budget_charged"] = false
 	}
 	if proposal != nil {
 		// 回传规范化后的别名：Agent 提的名字可能含非法字符被改写过，
@@ -333,9 +330,11 @@ func GetInbox(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// Agent 靠收件箱列表得知有哪些附件可下载，否则它不知道该调 attachment_id
+	ptrs := make([]*models.Mail, len(mails))
 	for i := range mails {
-		fillAttachments(r, &mails[i])
+		ptrs[i] = &mails[i]
 	}
+	fillAttachments(r, ptrs...)
 	total, _ := repo.CountUnread(r.Context(), agentName)
 
 	JSON(w, http.StatusOK, map[string]interface{}{
@@ -419,3 +418,74 @@ func parseInt(s string) (int, error) {
 	}
 	return n, nil
 }
+
+type markReadRequest struct {
+	// MailIDs 要标记为已读的邮件；省略/为空 = 把收件箱里全部未读标掉。
+	MailIDs []string `json:"mail_ids"`
+}
+
+// POST /api/v1/mail/read —— Agent 侧批量标记已读
+//
+// 为什么需要它：Agent 读完 read_inbox 后没有任何办法把邮件标掉，
+// 于是每次拉收件箱都把同一批旧邮件重新捞出来 —— 处理过的信和新来的信混在一起，
+// 模型分不清哪封该回。心跳里的未读数也永远只增不减。
+//
+// 鉴权写进 UPDATE 的 WHERE 而不是先查后改：不是发给自己的邮件根本改不动，
+// 既省一次查询，也没有「查完到改之间邮件被转走」的时间窗。
+func MarkInboxRead(w http.ResponseWriter, r *http.Request) {
+	agentName := middleware.GetAgentName(r)
+	if agentName == "" {
+		Error(w, http.StatusUnauthorized, "Unauthorized")
+		return
+	}
+
+	var req markReadRequest
+	// 允许空 body：`POST /mail/read` 不带任何内容 = 全部标掉
+	if r.ContentLength > 0 {
+		if err := Decode(r, &req); err != nil {
+			Error(w, http.StatusBadRequest, "Invalid JSON")
+			return
+		}
+	}
+
+	// 不给 id 就把收件箱里全部未读标掉。
+	// 这是 Agent 最常见的用法：一轮处理完，剩下的都不必再看。
+	if len(req.MailIDs) == 0 {
+		n, err := repo.MarkAllInboxReadFor(r.Context(), agentName)
+		if err != nil {
+			Error(w, http.StatusInternalServerError, "Failed to mark read")
+			return
+		}
+		JSON(w, http.StatusOK, map[string]any{"status": "read", "marked": n, "scope": "all"})
+		return
+	}
+
+	const maxBatch = 200
+	if len(req.MailIDs) > maxBatch {
+		Error(w, http.StatusBadRequest, fmt.Sprintf("一次最多标记 %d 封", maxBatch))
+		return
+	}
+	ids := make([]uuid.UUID, 0, len(req.MailIDs))
+	for _, s := range req.MailIDs {
+		id, err := uuid.Parse(strings.TrimSpace(s))
+		if err != nil {
+			Error(w, http.StatusBadRequest, "非法的 mail_id: "+s)
+			return
+		}
+		ids = append(ids, id)
+	}
+
+	n, err := repo.MarkMailsReadFor(r.Context(), agentName, ids)
+	if err != nil {
+		Error(w, http.StatusInternalServerError, "Failed to mark read")
+		return
+	}
+	// 不因为「有些 id 不是发给你的」而报错：那些 id 只是没被标掉。
+	// 报错会让整批失败，而 Agent 通常是把上一轮列出的 id 原样传回来，
+	// 其中可能混着已读的（幂等）——那不该是错误。
+	JSON(w, http.StatusOK, map[string]any{
+		"status":    "read",
+		"marked":    n,
+		"requested": len(ids),
+	})
+}

gateway/internal/handler/me.go

@@ -77,7 +77,7 @@ func MeSendMail(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	sessionID, parentMailID, err := resolveTarget(r, to, req.ReplyTo, user.Username, req.Subject, req.SessionAlias)
+	sessionID, parentMailID, err := resolveTarget(r, to, req.ReplyTo, user.Username, req.Subject, req.SessionAlias, "")
 	if err != nil {
 		writeErr(w, err, "Failed to resolve session")
 		return
@@ -85,14 +85,23 @@ func MeSendMail(w http.ResponseWriter, r *http.Request) {
 	// 人类发起的会话归属于该用户
 	_ = repo.SetSessionOwner(r.Context(), sessionID, user.ID)
 
-	// 新建会话时接受往返预算。只在新建时设：续谈已有会话若也接受这个字段，
+	// 新建会话时定往返预算。只在新建时设：续谈已有会话若也接受这个字段，
 	// 每封新信都会悄悄改掉对方正在遵守的预算，人却不一定意识到自己改了。
-	if req.MaxRounds != nil && parentMailID == nil {
-		if *req.MaxRounds < 0 {
-			Error(w, http.StatusBadRequest, "max_rounds 不能为负")
-			return
+	//
+	// 没显式给就用【收件 Agent 的默认值】。默认值挂在 Agent 上而不是全站一个数：
+	// 跑测试的小工具与重构整个模块的 Agent，合理来回数差一个量级。
+	if parentMailID == nil {
+		rounds := 0
+		if req.MaxRounds != nil {
+			if *req.MaxRounds < 0 {
+				Error(w, http.StatusBadRequest, "max_rounds 不能为负")
+				return
+			}
+			rounds = *req.MaxRounds
+		} else {
+			rounds = repo.DefaultRoundsFor(r.Context(), to.Name)
 		}
-		if _, err := repo.SetSessionBudget(r.Context(), sessionID, *req.MaxRounds); err != nil {
+		if _, err := repo.SetSessionBudget(r.Context(), sessionID, rounds); err != nil {
 			Error(w, http.StatusInternalServerError, "Failed to set session budget")
 			return
 		}
@@ -154,9 +163,11 @@ func MeGetInbox(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// 列表页要显示附件图标与下载入口
+	ptrs := make([]*models.Mail, len(mails))
 	for i := range mails {
-		fillAttachments(r, &mails[i])
+		ptrs[i] = &mails[i]
 	}
+	fillAttachments(r, ptrs...)
 	total, _ := repo.CountUnread(r.Context(), user.Username)
 
 	JSON(w, http.StatusOK, map[string]interface{}{
@@ -182,9 +193,11 @@ func MeGetSent(w http.ResponseWriter, r *http.Request) {
 
 	mails, err := repo.ListSentBy(r.Context(), user.Username, limit)
 	if err == nil {
+		ptrs := make([]*models.Mail, len(mails))
 		for i := range mails {
-			fillAttachments(r, &mails[i])
+			ptrs[i] = &mails[i]
 		}
+		fillAttachments(r, ptrs...)
 	}
 	if err != nil {
 		Error(w, http.StatusInternalServerError, "Failed to list sent")
@@ -224,6 +237,11 @@ func MeGetSessions(w http.ResponseWriter, r *http.Request) {
 		UpdatedAt    time.Time `json:"updated_at"`
 		MailCount    int       `json:"mail_count"`
 		UnreadCount  int       `json:"unread_count"`
+		// 往返预算随列表一并返回：预算是【任务】的属性，
+		// 工作列表上就应当看得见哪些任务快跑满了，
+		// 而不是点进去一个一个查。
+		MaxRounds  int `json:"max_rounds"`
+		UsedRounds int `json:"used_rounds"`
 	}
 
 	result := make([]SessionOut, 0, len(sessions))
@@ -239,6 +257,8 @@ func MeGetSessions(w http.ResponseWriter, r *http.Request) {
 			UpdatedAt:    s.UpdatedAt,
 			MailCount:    s.MailCount,
 			UnreadCount:  unread,
+			MaxRounds:    s.MaxRounds,
+			UsedRounds:   s.UsedRounds,
 		})
 	}
 

gateway/internal/handler/sessions.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/agentmail/gateway/internal/middleware"
+	"github.com/agentmail/gateway/internal/models"
 	"github.com/agentmail/gateway/internal/repo"
 	"github.com/agentmail/gateway/internal/sse"
 	"github.com/google/uuid"
@@ -52,6 +53,16 @@ func GetSession(w http.ResponseWriter, r *http.Request) {
 		Error(w, http.StatusInternalServerError, "Failed to get session mails")
 		return
 	}
+	// 会话线程要展示附件，逐封填充。
+	//
+	// 这里漏掉过：前端的会话视图走的是本端点（GET /sessions/{id}），
+	// 而不是下面那个 /sessions/{id}/mails —— 后者填了附件但没人调用，
+	// 于是 Agent 回信里的附件在 UI 上完全不存在。
+	ptrs := make([]*models.Mail, len(mails))
+	for i := range mails {
+		ptrs[i] = &mails[i]
+	}
+	fillAttachments(r, ptrs...)
 
 	JSON(w, http.StatusOK, map[string]interface{}{
 		"session": session,
@@ -71,9 +82,11 @@ func GetSessionMails(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// 会话线程要展示附件，逐封填充
+	ptrs := make([]*models.Mail, len(mails))
 	for i := range mails {
-		fillAttachments(r, &mails[i])
+		ptrs[i] = &mails[i]
 	}
+	fillAttachments(r, ptrs...)
 	JSON(w, http.StatusOK, map[string]interface{}{
 		"mails": emptySlice(mails),
 	})