magic-agent 1.0.111 → 2.3.0

package/internal/suggest/suggest_test.go

@@ -0,0 +1,218 @@
+package suggest
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// fakeEngine 记录请求，原样回一段文本（不发网络、不起 CLI）。
+type fakeEngine struct {
+	name string
+	text string
+	got  agent.Request
+}
+
+func (f *fakeEngine) Name() string           { return f.name }
+func (f *fakeEngine) Detect() (bool, string) { return true, "fake://" + f.name }
+func (f *fakeEngine) Complete(_ context.Context, req agent.Request) (agent.Response, error) {
+	f.got = req
+	return agent.Response{Text: f.text, Model: "fake-model"}, nil
+}
+
+func TestParseJSONObjectWithFence(t *testing.T) {
+	raw := "好的，这是建议：\n```json\n{\"suggestions\":[\"好的，执行吧\",\"先看一下 diff\"]}\n```\n"
+	got := Parse(raw, 3)
+	want := []string{"好的，执行吧", "先看一下 diff"}
+	if len(got) != len(want) {
+		t.Fatalf("Parse = %#v，期望 %#v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("Parse[%d] = %q，期望 %q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestParseBareArray(t *testing.T) {
+	got := Parse(`["继续","跑一遍测试"]`, 3)
+	if len(got) != 2 || got[0] != "继续" || got[1] != "跑一遍测试" {
+		t.Fatalf("Parse = %#v", got)
+	}
+}
+
+func TestParseLineFallback(t *testing.T) {
+	// 模型没按 JSON 回：只认「像一句指令」的短行，带解释/代码的丢掉。
+	raw := "1. 好的，执行吧。\n2、先看一下 diff\n- 这是解释：它改了三个文件\n```\ncode\n```"
+	got := Parse(raw, 3)
+	want := []string{"好的，执行吧", "先看一下 diff"}
+	if len(got) != len(want) {
+		t.Fatalf("Parse = %#v，期望 %#v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("Parse[%d] = %q，期望 %q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestParseRejectsNoise(t *testing.T) {
+	long := strings.Repeat("很", MaxLabelRunes+1)
+	raw := `{"suggestions":[
+		"继续",
+		"继续",
+		"AI 已经完成了这一步",
+		"助手建议你先跑测试",
+		"…半句话被截断了",
+		"` + long + `",
+		"好的，执行吧"
+	]}`
+	got := Parse(raw, 3)
+	if len(got) != 2 || got[0] != "继续" || got[1] != "好的，执行吧" {
+		t.Fatalf("Parse = %#v，去重/噪声过滤不对", got)
+	}
+	if n := len(Parse(raw, 1)); n != 1 {
+		t.Fatalf("count=1 时给了 %d 条", n)
+	}
+}
+
+func TestParseEmpty(t *testing.T) {
+	for _, raw := range []string{"", "   ", "{}", `{"suggestions":[]}`} {
+		if got := Parse(raw, 3); len(got) != 0 {
+			t.Fatalf("Parse(%q) = %#v，期望空", raw, got)
+		}
+	}
+}
+
+func TestNormalizeTrimsPunctuationAndQuotes(t *testing.T) {
+	got := Parse(`{"suggestions":["「好的，执行吧」。"]}`, 3)
+	if len(got) != 1 || got[0] != "好的，执行吧" {
+		t.Fatalf("Parse = %#v", got)
+	}
+}
+
+func TestPromptCarriesBothSides(t *testing.T) {
+	p := Prompt("帮我把登录页改完", "改动只在移动端静态资源。要我继续吗？", 3)
+	for _, want := range []string{"帮我把登录页改完", "要我继续吗？", "最多 3 条", `{"suggestions"`} {
+		if !strings.Contains(p, want) {
+			t.Fatalf("提示词缺少 %q：\n%s", want, p)
+		}
+	}
+	// 回复取结尾：超长时保留最后一段（下一步在那里）。
+	tail := strings.Repeat("前", 7000) + "最后一句：要我继续吗？"
+	p2 := Prompt("", tail, 3)
+	if !strings.Contains(p2, "最后一句：要我继续吗？") {
+		t.Fatalf("超长回复的结尾被截掉了")
+	}
+}
+
+func TestGenerateUsesToolsOffAndNoSession(t *testing.T) {
+	f := &fakeEngine{name: "fake-suggest", text: `{"suggestions":["好的，执行吧"]}`}
+	agent.Register(f) // 注册在 Engines() 首次调用之前：本包只找这个假引擎
+	res, err := Generate(context.Background(), Request{User: "改完了吗", Reply: "要我继续吗？", Engine: f.name})
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	if len(res.Suggestions) != 1 || res.Suggestions[0] != "好的，执行吧" {
+		t.Fatalf("Suggestions = %#v", res.Suggestions)
+	}
+	if res.Engine != f.name {
+		t.Fatalf("Engine = %q", res.Engine)
+	}
+	if f.got.Tools == nil || !f.got.Tools.IsOff() {
+		t.Fatalf("建议调用必须 ToolsOff（不带工具），实际 %#v", f.got.Tools)
+	}
+	if f.got.SessionID != "" || f.got.Continue {
+		t.Fatalf("建议调用不能续接会话（会污染上下文）：session=%q continue=%v", f.got.SessionID, f.got.Continue)
+	}
+	if f.got.JSONSchema == nil || len(f.got.JSONSchema.Required) != 1 {
+		t.Fatalf("缺少结构化输出契约")
+	}
+}
+
+func TestDropCreativeRestarts(t *testing.T) {
+	user := "写一个短篇恋爱小说"
+	complete := "# 她算得比天气预报准\n\n……林知夏把笔帽放回兜里，从此再也没咬扁过。"
+	cases := []struct {
+		name  string
+		items []string
+		reply string
+		want  []string
+	}{
+		{"另起一篇", []string{"再来一篇职场题材的", "跑一下测试"}, complete, []string{"跑一下测试"}},
+		{"再写一个故事", []string{"再写一个校园故事"}, complete, []string{}},
+		{"再来个职场篇", []string{"再来个职场篇"}, complete, []string{}},
+		{"换个校园题材", []string{"换个校园题材的"}, complete, []string{}},
+		{"下一篇", []string{"下一篇写职场"}, complete, []string{}},
+		{"写个番外", []string{"写个番外"}, complete, []string{}},
+		{"换题材", []string{"换个题材"}, complete, []string{}},
+		{"成品后继续写", []string{"继续写下一章"}, complete, []string{}},
+		{"未完待续保留", []string{"继续写下一章"}, "# 第三章\n\n……未完待续", []string{"继续写下一章"}},
+		{"AI 主动邀请保留", []string{"再来一篇"}, complete + "\n\n要不要我再写一篇？", []string{"再来一篇"}},
+		{"成品后裸继续", []string{"继续"}, complete, []string{}},
+		{"AI 问要继续保留", []string{"继续"}, complete + "\n\n要继续吗？", []string{"继续"}},
+		{"写代码不误杀", []string{"再写一个单元测试"}, "func Add() {}", []string{"再写一个单元测试"}},
+	}
+	for _, tc := range cases {
+		got := dropCreativeRestarts(tc.items, user, tc.reply)
+		if len(got) != len(tc.want) {
+			t.Fatalf("%s: dropCreativeRestarts = %#v，期望 %#v", tc.name, got, tc.want)
+		}
+		for i := range tc.want {
+			if got[i] != tc.want[i] {
+				t.Fatalf("%s: [%d] = %q，期望 %q", tc.name, i, got[i], tc.want[i])
+			}
+		}
+	}
+	// 非创作轮次不启用这条过滤：写代码时「再来一篇」虽怪，但不能由这里替用户判死。
+	if got := dropCreativeRestarts([]string{"再来一篇职场题材的"}, "修一下登录 bug", complete); len(got) != 1 {
+		t.Fatalf("非创作轮次被误过滤：%#v", got)
+	}
+	// 用户只说「继续」，但 AI 交的是一篇完整创作：也按创作轮次处理。
+	longStory := "# 长夜\n\n" + strings.Repeat("这是一段完整的故事。", 60)
+	if got := dropCreativeRestarts([]string{"再来一篇职场题材的"}, "继续", longStory); len(got) != 0 {
+		t.Fatalf("创作成品后的续篇没被过滤：%#v", got)
+	}
+	// 带代码块的工程回答不能被当成创作成品。
+	codeDoc := "# 修复说明\n\n```go\nfunc Add(){}\n```\n" + strings.Repeat("测试通过。", 100)
+	if got := dropCreativeRestarts([]string{"再写一个测试"}, "继续", codeDoc); len(got) != 1 {
+		t.Fatalf("工程回答被误判成创作：%#v", got)
+	}
+}
+
+func TestGenerateFiltersCreativeRestart(t *testing.T) {
+	f := &fakeEngine{name: "fake-suggest-creative", text: `{"suggestions":["再来一篇职场题材的","跑一下测试"]}`}
+	agent.Register(f)
+	res, err := Generate(context.Background(), Request{
+		User: "写一个短篇恋爱小说", Reply: "# 标题\n\n……故事收尾，没有提问。", Engine: f.name,
+	})
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	if len(res.Suggestions) != 1 || res.Suggestions[0] != "跑一下测试" {
+		t.Fatalf("Suggestions = %#v，另起一篇应被过滤", res.Suggestions)
+	}
+}
+
+func TestPromptStopsCreativeRestart(t *testing.T) {
+	p := Prompt("再来一篇职场题材的", "# 甲方的那句话\n\n……沈清把合同收进抽屉。", 3)
+	for _, want := range []string{"交付型任务", "必须给空数组", "再来一篇", "用户上一句就是"} {
+		if !strings.Contains(p, want) {
+			t.Fatalf("提示词缺少 %q：\n%s", want, p)
+		}
+	}
+}
+
+func TestGenerateEmptyReplyShortCircuits(t *testing.T) {
+	f := &fakeEngine{name: "fake-suggest-empty", text: "不该被调用"}
+	agent.Register(f)
+	res, err := Generate(context.Background(), Request{Reply: "   ", Engine: f.name})
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	if len(res.Suggestions) != 0 || f.got.Messages != nil {
+		t.Fatalf("空正文不该调引擎：%#v %#v", res.Suggestions, f.got.Messages)
+	}
+}

package/internal/team/board.go

@@ -10,6 +10,7 @@ package team
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 	"sync"
 	"time"
 
@@ -38,11 +39,33 @@ type TaskRow struct {
 	Deps   []string `json:"deps,omitempty"`
 	// Note 失败 / 跳过的一句话原因（成功时为空）。
 	Note string `json:"note,omitempty"`
+	// Active 正在跑的那一行**此刻在干什么**（「等待授权」「已 40 秒无新输出」）。
+	//
+	// 2026-10-22 用户：「子任务进度也不需要显示多行 在任务列表中显示即可」——
+	// 以前心跳是一条条 notice（主会话里长出十几行「仍在运行…」），现在只挂在这一行上：
+	// 快照每次整份重发，进度就只剩一处可看，也不占画布。只对 running 行写。
+	//
+	// ⚠️ 它是**状态说明**，不是标题：客户端画在「标题 + 状态」的次要位置
+	// （2026-10-22 用户：「应该显示子任务标题和状态耗时」）。标题永远取 Title。
+	Active string `json:"active,omitempty"`
+	// RuntimeMs 这一行**已经跑了多久 / 最终跑了多久**（毫秒，0 = 还没开跑）。
+	//
+	// pending 行是 0；running 行随快照整份重发不断增大；落定后冻结成总耗时
+	// （失败的也冻结 —— 「跑了 3 分钟然后失败」比光一个红叉有用）。由 core 给绝对值，
+	// 客户端不做本地计时：多端重连 / 历史回放看到的就是当时的数，不会各自跳字。
+	RuntimeMs int64 `json:"runtime_ms,omitempty"`
 	// SessionID / RunID 这一行的子会话（点进去看过程）。RunID 在任务一开跑就有，
 	// SessionID 要等引擎给出；两个都可能为空（调用方没开登记 / 引擎不给 id）。
 	SessionID string `json:"session_id,omitempty"`
 	RunID     string `json:"run_id,omitempty"`
 	Output    string `json:"output,omitempty"`
+	// Arts 这一行**实际交付的产物**（绝对路径）。
+	//
+	// 2026-10-22 用户：「主会话产物要显示子任务的产物」—— 子任务的产物以前只出现在
+	// result.tasks[].arts（要等整轮结束才下发一份终态信封），主会话的画布上到那时
+	// 才看得到；而任务列表卡是随状态一路整份重发的，把产物挂在这一行上，某个子任务
+	// 一落定，主会话里立刻就能看到它交了什么东西（图 → 缩略图，文档 → 卡片）。
+	Arts []string `json:"arts,omitempty"`
 }
 
 // Board 任务列表的唯一写者（并发安全）。
@@ -54,13 +77,33 @@ type Board struct {
 	rows  map[string]*TaskRow
 	// last 每一行最后一次「有动静」的时间（子事件 / 状态变化），心跳据此播报。
 	last map[string]time.Time
+	// started 每一行开跑的时刻（RuntimeMs 的起点）。
+	started map[string]time.Time
 }
 
 func newBoard(emit func(agent.StreamEvent)) *Board {
 	return &Board{
-		emit: emit,
-		rows: make(map[string]*TaskRow),
-		last: make(map[string]time.Time),
+		emit:    emit,
+		rows:    make(map[string]*TaskRow),
+		last:    make(map[string]time.Time),
+		started: make(map[string]time.Time),
+	}
+}
+
+// stampLocked 按开跑时刻刷新一行的运行时长（调用方持锁）。
+//
+// 每次出快照前统一刷一遍：状态没变的行也不会停在上一份快照的秒数上
+// （心跳 quiet 与状态变化都会整份重发，用户看到的就是「一路在涨」）。
+func (b *Board) stampLocked() {
+	now := time.Now()
+	for _, id := range b.order {
+		row := b.rows[id]
+		if row == nil || row.Status != RowRunning {
+			continue
+		}
+		if st, ok := b.started[id]; ok && !st.IsZero() {
+			row.RuntimeMs = now.Sub(st).Milliseconds()
+		}
 	}
 }
 
@@ -81,6 +124,7 @@ func (b *Board) snapshotLocked() string {
 	if len(b.order) == 0 {
 		return ""
 	}
+	b.stampLocked()
 	rows := make([]TaskRow, 0, len(b.order))
 	for _, id := range b.order {
 		rows = append(rows, *b.rows[id])
@@ -127,7 +171,10 @@ func (b *Board) start(t Task, engine, model string) {
 		row.Status = RowRunning
 		row.Engine, row.Model = engine, model
 		row.Note = ""
+		row.Active = ""
+		row.RuntimeMs = 0
 		b.last[t.ID] = time.Now()
+		b.started[t.ID] = b.last[t.ID]
 	})
 }
 
@@ -171,6 +218,15 @@ func (b *Board) finish(t Task, r TaskResult) {
 			row.SessionID = r.SessionID
 		}
 		row.Output = r.OutputPath
+		/* 产物跟着结局一起落在这一行上：主会话画布据此立即（不必等整轮 result）
+		   显示子任务交了什么东西。空结果也显式清空，免得重试时留着上一次的旧产物。 */
+		row.Arts = r.Arts
+		row.Active = "" // 落定了就没有「此刻在干什么」了
+		/* 运行时长冻结在落定这一刻：失败 / 跳过的行同样有数 ——
+		   「跑了 3 分钟才失败」和「一开跑就失败」是两件事。 */
+		if st, ok := b.started[t.ID]; ok && !st.IsZero() {
+			row.RuntimeMs = time.Since(st).Milliseconds()
+		}
 		if r.State != TaskDone {
 			row.Note = oneLine(r.Reason)
 		}
@@ -179,21 +235,47 @@ func (b *Board) finish(t Task, r TaskResult) {
 }
 
 // touch 子任务有事件了（刷新心跳时间；事件本身写子会话的日志，不进主会话）。
-func (b *Board) touch(id string) {
+func (b *Board) touch(id string, ev agent.StreamEvent) {
 	b.mu.Lock()
-	defer b.mu.Unlock()
-	if _, ok := b.rows[id]; ok {
-		b.last[id] = time.Now()
+	row := b.rows[id]
+	if row == nil {
+		b.mu.Unlock()
+		return
+	}
+	b.last[id] = time.Now()
+	/* 又有输出了 → 那一行的「已 N 秒无新输出」不再成立。只改内存不发快照：
+	   下一条状态变化会带上；否则每条子事件都要整份广播一次，白白刷屏。 */
+	row.Active = ""
+	/* 但**卡在授权上**是另一种情况：子引擎停在那里等答复，事件停了也不会再动 —— 只写
+	   「已 900 秒无新输出」等于什么都没说。把「需要授权：Read（等待用户选择）」直接挂到
+	   这一行（它属于任务列表，不占画布）。团队模式没有作答通道（子任务不共享上下文），
+	   用户能做的只有去那条子会话里看 / 停掉它，所以这里只报事实。 */
+	var snapshot string
+	if ev.Kind == agent.KindAsk {
+		label := strings.TrimSpace(ev.Text)
+		if label == "" {
+			label = "等待用户处理"
+		}
+		row.Active = label
+		snapshot = b.snapshotLocked()
+	}
+	b.mu.Unlock()
+	if snapshot != "" {
+		b.emit(agent.StreamEvent{Kind: agent.KindTasks, Text: snapshot})
 	}
 }
 
-// quietLines 返回「已经 taskQuiet 没动静」的运行中任务的播报文案，并把它们的活跃时间
-// 推到此刻 —— 同一条任务因此每 taskHeartbeat 才播一次，秒数持续增长。
-func (b *Board) quietLines() []string {
+// quiet 把「已经 taskQuiet 没动静」的运行中任务的**行内进度**写上去，并把它们的
+// 活跃时间推到此刻 —— 同一条任务因此每 taskHeartbeat 才回写一次，秒数持续增长。
+//
+// 2026-10-22 用户：「子任务进度也不需要显示多行 在任务列表中显示即可」：以前这里
+// 返回一串文案，由 executeWithHeartbeat 逐条发 notice —— 主会话的画布上于是长出
+// 十几行「仍在运行…（已 40 秒无新输出）」。现在只更新任务列表卡对应那一行，进度
+// 只有一处可看；「有动静了」也要把 Active 清掉，否则那一行会停在最后一次心跳的秒数上。
+func (b *Board) quiet() {
 	b.mu.Lock()
-	defer b.mu.Unlock()
+	changed := false
 	now := time.Now()
-	var out []string
 	for _, id := range b.order {
 		row := b.rows[id]
 		if row == nil || row.Status != RowRunning {
@@ -204,10 +286,20 @@ func (b *Board) quietLines() []string {
 			continue
 		}
 		b.last[id] = now
-		out = append(out, fmt.Sprintf("团队模式：%s「%s」仍在运行…（已 %d 秒无新输出）",
-			id, row.Title, int(now.Sub(last).Seconds())))
+		if s := fmt.Sprintf("已 %d 秒无新输出", int(now.Sub(last).Seconds())); s != row.Active {
+			row.Active = s
+			changed = true
+		}
+	}
+	if !changed {
+		b.mu.Unlock()
+		return
+	}
+	text := b.snapshotLocked()
+	b.mu.Unlock()
+	if text != "" {
+		b.emit(agent.StreamEvent{Kind: agent.KindTasks, Text: text})
 	}
-	return out
 }
 
 // notice 往主会话发一条过程提示（不属于任何子任务）。

package/internal/team/execute.go

@@ -268,7 +268,7 @@ func runAttempt(ctx context.Context, opts Options, t Task, runDir string, route
 		if sub != nil {
 			sub.Push(ev)
 		}
-		board.touch(t.ID)
+		board.touch(t.ID, ev)
 	})
 
 	if err != nil {

package/internal/team/team.go

@@ -146,6 +146,12 @@ type Options struct {
 
 	// OnEvent 事件出口（由 CLI 层接到 eventSink）。并发安全由调用方保证。
 	OnEvent func(agent.StreamEvent)
+	// OnTick 计划阶段的心跳（每隔 planHeartbeat 一次），**不发事件**。
+	//
+	// 为什么要它：计划阶段是非流式调用，几十秒里一条事件都没有；这一段既不能往
+	// 主会话里刷「已 N 秒」（用户明确不要多行进度），又不能让别端把这一轮判成死。
+	// CLI 层把它接到会话登记表的续期上（见 cli/team.go）。空 = 什么都不做。
+	OnTick func()
 
 	// OpenSubSession 为一个子任务开一条**普通会话**（登记 + 独立日志）。
 	//
@@ -244,7 +250,7 @@ func Run(ctx context.Context, opts Options) (Result, error) {
 	/* 计划阶段：主引擎**关工具**跑一次。
 	   关工具不是为了省事 —— 计划必须是可解析的结构化输出，开着工具时模型会把
 	   中间过程（读文件 / 跑命令）混进正文，解析成功率会掉下来。 */
-	plan, planSession, planErr := planWithHeartbeat(ctx, opts, emit)
+	plan, planSession, planErr := planWithHeartbeat(ctx, opts, opts.OnTick)
 	degraded := ""
 	if planErr != nil {
 		degraded = "计划生成失败，已降级为单任务：" + planErr.Error()
@@ -322,24 +328,30 @@ func Run(ctx context.Context, opts Options) (Result, error) {
 	return res, nil
 }
 
-// planHeartbeat 计划阶段的进度播报间隔。
-const planHeartbeat = 5 * time.Second
-
-// planWithHeartbeat 跑计划阶段，等待期间定期播报「已等 N 秒」。
+// planHeartbeat 计划阶段的心跳间隔。
 //
 // 计划是一次**非流式**调用（ToolsOff，要模型整段吐 JSON），实测 40 秒起步；
-// 这期间一条事件都没有，客户端看起来就是「发出去了没反应」。心跳不伪造进度，
-// 只证明 core 还活着 —— 这是「无响应」里最长、也最容易被当成挂死的一段。
+// 这期间一条事件都没有，客户端看起来就是「发出去了没反应」。
+// 心跳**只证明 core 还活着**，不再往主会话里发「已 N 秒」的 notice
+// （2026-10-22 用户：「子任务进度也不需要显示多行 在任务列表中显示即可」）：
+// 计划阶段任务列表还没建出来，所以这一段的「还活着」由 core 侧续期登记表
+// （cli/team.go 的 emit → Touch）证明，客户端跟随时不会被判成终态而提前收尾。
+const planHeartbeat = 5 * time.Second
+
+// planWithHeartbeat 跑计划阶段，期间按 planHeartbeat 打点续期。
 //
-// 退出顺序：close(stop) 之后 wg.Wait()，保证心跳 goroutine 彻底停了才返回，
-// 否则它的 notice 可能插到「计划已生成」后面。
-func planWithHeartbeat(ctx context.Context, opts Options, emit func(agent.StreamEvent)) (Plan, string, error) {
+// 续期而不是发事件：画面上一行字都不多，但别端的尾随连接能从 updated_at 看出
+// 这一轮没死。退出顺序 close(stop) → wg.Wait()：心跳彻底停了才返回，避免它
+// 把 lastTouch 推到「计划已生成」之后。
+func planWithHeartbeat(ctx context.Context, opts Options, touch func()) (Plan, string, error) {
 	stop := make(chan struct{})
 	var wg sync.WaitGroup
+	if touch == nil {
+		touch = func() {}
+	}
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		start := time.Now()
 		tick := time.NewTicker(planHeartbeat)
 		defer tick.Stop()
 		for {
@@ -349,10 +361,7 @@ func planWithHeartbeat(ctx context.Context, opts Options, emit func(agent.Stream
 			case <-ctx.Done():
 				return
 			case <-tick.C:
-				emit(agent.StreamEvent{
-					Kind: agent.KindNotice,
-					Text: fmt.Sprintf("团队模式：正在生成计划…（已 %d 秒）", int(time.Since(start).Seconds())),
-				})
+				touch()
 			}
 		}
 	}()
@@ -366,7 +375,9 @@ func planWithHeartbeat(ctx context.Context, opts Options, emit func(agent.Stream
 //
 // 子引擎可能几十秒到十几分钟不吐一条事件：模型侧 request 超时后 claude CLI 会自己
 // 重试，重试期间不产生任何 stream-json。此时任务列表里只有一行「运行中」，跟卡死
-// 无法区分。心跳不伪造进度，只证明「这个子任务还活着」。
+// 无法区分。心跳不伪造进度，只证明「这个子任务还活着」——
+// 落点只在**任务列表那一行**（TaskRow.Active），不往主会话里发 notice（2026-10-22
+// 用户：「子任务进度也不需要显示多行 在任务列表中显示即可」）。
 const (
 	taskHeartbeat = 20 * time.Second
 	taskQuiet     = 30 * time.Second
@@ -388,9 +399,7 @@ func executeWithHeartbeat(ctx context.Context, opts Options, plan Plan, runDir s
 			case <-ctx.Done():
 				return
 			case <-tick.C:
-				for _, text := range board.quietLines() {
-					board.notice(text)
-				}
+				board.quiet()
 			}
 		}
 	}()

package/internal/team/team_test.go

@@ -1323,31 +1323,50 @@ func TestWriteOutputRecordsMissing(t *testing.T) {
 	}
 }
 
-// 执行阶段心跳：只播报「还在跑且很久没动静」的任务，收尾的不再播。
-func TestBoardQuietLinesOnlyAnnouncesSilentRunningTasks(t *testing.T) {
-	b := newBoard(func(agent.StreamEvent) {})
+// 执行阶段心跳：只给「还在跑且很久没动静」的那一行挂行内进度，收尾的不再挂。
+//
+// 2026-10-22 用户：「子任务进度也不需要显示多行 在任务列表中显示即可」——
+// 心跳落点从一串 notice 改成任务列表行的 Active，所以断言也看行。
+func TestBoardQuietOnlyMarksSilentRunningTasks(t *testing.T) {
+	var events []agent.StreamEvent
+	b := newBoard(func(ev agent.StreamEvent) { events = append(events, ev) })
 	t1 := Task{ID: "t1", Kind: KindText, Title: "写介绍"}
 	t2 := Task{ID: "t2", Kind: KindImage, Title: "画封面"}
 	t3 := Task{ID: "t3", Kind: KindText, Title: "汇总图"}
 	for _, task := range []Task{t1, t2, t3} {
 		b.add(task, Route{})
 	}
+	b.announce()
+	events = nil
 	b.start(t1, "e", "")
 	b.start(t2, "e", "")
 	b.finish(t3, TaskResult{ID: "t3", State: TaskDone})
+	events = nil
 
 	// t1 刚刚有输出；t3 已收尾；t2 静默超过阈值。
-	b.touch("t1")
+	b.touch("t1", agent.StreamEvent{Kind: agent.KindText})
 	b.mu.Lock()
 	b.last["t2"] = time.Now().Add(-time.Minute)
 	b.mu.Unlock()
 
-	got := b.quietLines()
-	if len(got) != 1 || !strings.Contains(got[0], "t2") || !strings.Contains(got[0], "画封面") {
-		t.Fatalf("只该播报静默中的 t2，得到 %v", got)
+	b.quiet()
+	if len(events) != 1 || events[0].Kind != agent.KindTasks {
+		t.Fatalf("心跳应当整份重发一次任务列表快照，得到 %d 条 %v", len(events), events)
+	}
+	if !strings.Contains(events[0].Text, "无新输出") {
+		t.Fatalf("快照里应当带上这一行的行内进度：%s", events[0].Text)
+	}
+	b.mu.Lock()
+	active1, active2, active3 := b.rows["t1"].Active, b.rows["t2"].Active, b.rows["t3"].Active
+	b.mu.Unlock()
+	if active2 == "" || active1 != "" || active3 != "" {
+		t.Fatalf("只该给静默中的 t2 挂进度，得到 t1=%q t2=%q t3=%q", active1, active2, active3)
 	}
-	if again := b.quietLines(); len(again) != 0 {
-		t.Fatalf("刚播过的任务不应立刻重复：%v", again)
+
+	events = nil
+	b.quiet()
+	if len(events) != 0 {
+		t.Fatalf("刚刷过的行不应立刻重复发快照：%v", events)
 	}
 }
 
@@ -1363,24 +1382,58 @@ func TestBoardTouchKeepsRunningRowAlive(t *testing.T) {
 	b.last["t2"] = time.Now().Add(-time.Minute)
 	b.mu.Unlock()
 
-	b.touch("t2")
-	if got := b.quietLines(); len(got) != 0 {
-		t.Fatalf("刚有动静的任务不该被心跳播报：%v", got)
-	}
+	b.touch("t2", agent.StreamEvent{Kind: agent.KindText})
+	b.quiet()
 	b.mu.Lock()
 	row := b.rows["t2"]
 	b.mu.Unlock()
 	if row == nil || row.Status != RowRunning {
 		t.Fatalf("内部事件不该改变这一行的状态，得到 %+v", row)
 	}
+	if row.Active != "" {
+		t.Fatalf("刚有动静的任务不该挂着「无新输出」：%q", row.Active)
+	}
 
 	// 真正的收尾由 finish 落定（之后不再进心跳候选）。
 	b.finish(t2, TaskResult{ID: "t2", State: TaskDone})
 	b.mu.Lock()
 	b.last["t2"] = time.Now().Add(-time.Minute)
 	b.mu.Unlock()
-	if got := b.quietLines(); len(got) != 0 {
-		t.Fatalf("已收尾的任务不该被心跳播报：%v", got)
+	b.quiet()
+	b.mu.Lock()
+	row = b.rows["t2"]
+	b.mu.Unlock()
+	if row.Active != "" {
+		t.Fatalf("已收尾的任务不该被心跳挂进度：%q", row.Active)
+	}
+}
+
+// 卡在授权上的子任务：行内进度必须说「等待授权」，而不是「已 N 秒无新输出」。
+// 回归：2026-10-22 实测 --team-permission accept-edits 下子引擎读任务书也要授权，
+// 两个子任务一起停在那里十几分钟，主会话里没有任何一处看得出来它在等人。
+func TestBoardTouchShowsPendingAsk(t *testing.T) {
+	var events []agent.StreamEvent
+	b := newBoard(func(ev agent.StreamEvent) { events = append(events, ev) })
+	t1 := Task{ID: "t1", Kind: KindText, Title: "写介绍"}
+	b.add(t1, Route{})
+	b.start(t1, "e", "")
+	events = nil
+
+	b.touch("t1", agent.StreamEvent{Kind: agent.KindAsk, Text: "需要授权：Read（等待用户选择）"})
+	if len(events) != 1 || events[0].Kind != agent.KindTasks {
+		t.Fatalf("卡在授权上要当场重发一次快照，得到 %d 条", len(events))
+	}
+	if !strings.Contains(events[0].Text, "等待用户选择") {
+		t.Fatalf("快照里应当带着等待授权的说明：%s", events[0].Text)
+	}
+
+	// 有后续输出（用户放行 / 引擎自己继续）→ 行内进度清空。
+	b.touch("t1", agent.StreamEvent{Kind: agent.KindText, Text: "继续"})
+	b.mu.Lock()
+	active := b.rows["t1"].Active
+	b.mu.Unlock()
+	if active != "" {
+		t.Fatalf("恢复输出后不该还挂着等待授权：%q", active)
 	}
 }
 

package/npm/apk/version.json

@@ -0,0 +1,5 @@
+{
+  "version": "2.3.0",
+  "versionCode": 20300,
+  "builtAt": "2026-10-23T00:29:48.082Z"
+}