magic-agent 2.1.5 → 2.3.0

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

@@ -1,5 +1,5 @@
 {
-  "version": "2.1.3",
-  "versionCode": 20103,
-  "builtAt": "2026-10-22T11:18:59.511Z"
+  "version": "2.3.0",
+  "versionCode": 20300,
+  "builtAt": "2026-10-23T00:29:48.082Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magic-agent",
-  "version": "2.1.5",
+  "version": "2.3.0",
   "description": "专业的 agent CLI 代理工具 - 统一 claude / codebuddy / trae / llm / codex / openclaw 引擎",
   "license": "MIT",
   "bin": {
@@ -14,9 +14,12 @@
     "prepack": "node npm/build.js",
     "postinstall": "node npm/install.js",
     "check:ui": "node tests/check-ui-spec.mjs",
+    "check:pin": "node tests/check-task-pin.mjs",
     "check:conv": "node tests/check-conv-shards.mjs",
     "check:conv-host": "node tests/check-conv-shared-host.mjs",
-    "check:conv-comp": "node tests/check-conv-component.mjs"
+    "check:conv-mobile": "node tests/check-conv-mobile-host.mjs",
+    "check:conv-comp": "node tests/check-conv-component.mjs",
+    "check:conv-queue": "node tests/check-conv-queue.mjs"
   },
   "files": [
     "npm/bin/",