magic-agent 1.0.49 → 1.0.109

package/internal/agent/capability.go

@@ -24,7 +24,10 @@ import "sort"
 //
 // 递增规则：只增字段（向后兼容）不升版本；一旦有字段改名、语义变化或删除，
 // 必须升版本 —— 老客户端会因版本不匹配而拒绝启动，这正是我们想要的结果。
-const ContractVersion = 1
+//
+// v2（2026-10-22）：团队模式 `tasks[]` 的 `role` 改为**必出**且是唯一作者字段，
+// `kind` 由角色派生（只读）。老客户端会把 `kind` 当作者字段解释，语义已变。
+const ContractVersion = 2
 
 // 能力 id。命名规则：`域.能力`，域只有 session / workspace / attachment /
 // model / engine 五个，客户端按域分组渲染即可。
@@ -146,9 +149,20 @@ const (
 	FeatureSessionEvents = "feature.session.events"
 	// FeatureSessionControl `--stream --control`：stdin NDJSON 控制通道（打断 / 收工 / 回审批）。
 	FeatureSessionControl = "feature.session.control"
+	// FeatureSessionTeam `--team`：团队模式（主引擎拆任务、子引擎分头执行、主引擎汇总）。
+	//
+	// 为什么归 core 而不是某个引擎：它是**会话层的一种运行模式**，任何能当主引擎的
+	// 引擎都能用它（见 internal/team）。客户端据此决定要不要显示团队开关 ——
+	// 老版本 core 没有这个 feature，界面必须把开关置灰而不是静默下发一个不认识的字段。
+	FeatureSessionTeam = "feature.session.team"
+	// FeatureRequirements `--requirements` / `--consolidate-requirements`：会话自动聚合成需求。
+	//
+	// 客户端据此决定要不要显示「需求」页签：老版本 core 没有这个 feature，
+	// 界面必须把入口藏起来，而不是给一个点下去只会报错的按钮。
+	FeatureRequirements = "feature.requirements"
 )
 
 // CoreFeatures 返回 core 自身提供的通道能力（字典序，稳定）。
 func CoreFeatures() []string {
-	return []string{FeatureSessionControl, FeatureSessionEvents}
+	return []string{FeatureRequirements, FeatureSessionControl, FeatureSessionEvents, FeatureSessionTeam}
 }

package/internal/agent/claude.go

@@ -232,10 +232,11 @@ func (e *ClaudeEngine) buildArgsBase(req Request) []string {
 		args = append(args, "--tools", strings.Join(tools.Allowlist(), ","),
 			"--permission-mode", claudePermissionMode(req.Permission))
 	}
+	/* 没指定模型就**不传**这个 flag，让 CLI 用自己的默认档。
+	   以前缺省分支会 append(DefaultClaudeModel)，而它是空串 —— 命令行于是变成
+	   `--model  --effort max`（空串占位）。空值参数没有语义，纯属给 CLI 埋雷。 */
 	if m := stripModelPrefix(req.Model); m != "" {
 		args = append(args, "--model", m)
-	} else {
-		args = append(args, "--model", DefaultClaudeModel)
 	}
 	// 推理档位：claude 的 --effort 只认 low/medium/high/xhigh/max（无 minimal），
 	// 传 minimal 时降级为 low，避免 clap 直接拒绝整轮调用。

package/internal/agent/codebuddy.go

@@ -307,10 +307,16 @@ func (c codebuddyCore) complete(ctx context.Context, req Request) (Response, err
 	if strings.TrimSpace(text) == "" {
 		return Response{}, fmt.Errorf("%s CLI 返回内容仅为请求回显（无模型正文）", c.name)
 	}
+	// session_id 通常出现在 result 行；老版本 / 部分模型只在 init 行给，
+	// 此时回落到流里记住的那个，保证续接链路不断。
+	sid := fin.SessionID
+	if sid == "" {
+		sid = acc.SessionID
+	}
 	return Response{
 		Text:      text,
 		Model:     fin.Model,
-		SessionID: fin.SessionID,
+		SessionID: sid,
 		Latency:   time.Since(start),
 	}, nil
 }

package/internal/agent/codex_test.go

@@ -27,7 +27,10 @@ func TestCodexBuildArgsNewSession(t *testing.T) {
 	dir := t.TempDir()
 	w, log := argsCaptureCLI(t, dir, "codex", codexStubWithText("hi from codex"))
 	e := &CodexEngine{BinPath: w.bin}
+	// 工具默认是 on（toolsOrDefault），on/白名单会走全放行；这里显式关掉，
+	// 断言 off 模式的 read-only 沙箱减法。
 	if _, err := e.Complete(context.Background(), Request{
+		Tools:    ToolsOff,
 		Messages: []Message{{Role: "user", Content: "hi"}},
 	}); err != nil {
 		t.Fatalf("Complete: %v", err)

package/internal/agent/custom_models_test.go

@@ -440,6 +440,11 @@ func TestSyncCustomModelsFromApp_CorruptExistingFileLeftUntouched(t *testing.T)
 }
 
 func TestEnsureCustomModelEndpoint_OnlyCustomLocal(t *testing.T) {
+	// 前两段断言走注入的 configDir，前提是环境里没有 CODEBUDDY_CONFIG_DIR ——
+	// 显式设了它时落点就该跟着走（第三段才验这个）。本机 shell 带着它，
+	// 不清掉的话「自定义模型应触发同步」会去查一个没被写入的目录。
+	t.Setenv("CODEBUDDY_CONFIG_DIR", "")
+
 	dir := t.TempDir()
 	acc := filepath.Join(dir, "acc.json")
 	writeJSON(t, acc, appCacheFixture())

package/internal/agent/dsh.go

@@ -549,17 +549,20 @@ func (e *DshEngine) streamHeadless(ctx context.Context, req Request, bin, sessio
 
 	var (
 		thinking  strings.Builder
+		body      strings.Builder // text 事件累积（final 缺失时的正文兜底）
 		tools     []ToolCall
 		callIdx   = map[string]int{}
 		final     string // `--json` 的 final 事件（整轮正文），权威
 		learnedID string // 会话抬头里的 id（老接口另用：本轮的会话 id）
 		streamed  bool   // 是否已逐条发过正文
+		sawEvent  bool   // 是否真的解析出过事件行（= stdout 是事件流，不能当正文）
 	)
 	onLine := func(line string) error {
 		ev, ok := parseDshJSONEvent(line)
 		if !ok {
 			return nil // 非事件行（启动日志 / 坏行）忽略
 		}
+		sawEvent = true
 		switch ev.Type {
 		case "session":
 			// 会话抬头：headless 回的是**同一条会话**的 id，回报给「看历史」持久化。
@@ -578,6 +581,7 @@ func (e *DshEngine) streamHeadless(ctx context.Context, req Request, bin, sessio
 				return nil
 			}
 			streamed = true
+			body.WriteString(ev.Text)
 			emit(StreamEvent{Kind: KindText, Text: ev.Text})
 		case "tool_call":
 			callArgs := dshJSONArgs(ev.Input)
@@ -623,9 +627,17 @@ func (e *DshEngine) streamHeadless(ctx context.Context, req Request, bin, sessio
 		})
 	}
 
-	// 正文：final 事件最权威；没有（老版本 / 事件缺失）就用 stdout 全文。
+	// 正文：final 事件最权威；final 缺失时用 text 事件累积的正文兜底。
+	// ⚠️ stdout 一旦被解析成事件流（sawEvent），就**绝不能**再当正文：本轮没提交正文时
+	// dsh 的 final.text 就是空串，拿 stdout 兜底会把一屏 `{"type":"session"...}` 原样
+	// 渲染进气泡（真实报障：对话正文显示原始事件 JSON）。能力探测失败时 caps 是乐观默认
+	// （JSON=true），所以判据用 sawEvent 而不是 caps.JSON —— 真老版本输出纯文本，解析不出
+	// 任何事件行，仍按「stdout 即正文」处理。
 	text := strings.TrimSpace(final)
-	if text == "" {
+	if text == "" && sawEvent {
+		text = strings.TrimSpace(body.String())
+	}
+	if text == "" && !sawEvent {
 		text = strings.TrimSpace(stdout)
 	}
 
@@ -655,6 +667,10 @@ func (e *DshEngine) streamHeadless(ctx context.Context, req Request, bin, sessio
 			wrapCliError("dsh", stdout, stderrText, runErr)
 	}
 	if resp.Text == "" {
+		if sawEvent {
+			return StreamResult{Response: resp, Thinking: thinking.String(), Tools: tools},
+				fmt.Errorf("dsh 本轮没有输出最终正文（--json 事件流里既没有 final.text 也没有 text 事件）")
+		}
 		return StreamResult{Response: resp, Thinking: thinking.String(), Tools: tools},
 			fmt.Errorf("dsh CLI returned empty result")
 	}

package/internal/agent/dsh_test.go

@@ -75,8 +75,10 @@ func TestDshCapabilities(t *testing.T) {
 	if got := AttachmentSupportOf("dsh"); got != "prompt" {
 		t.Errorf("headless 下 AttachmentSupportOf(dsh) = %q want prompt（无图片通道）", got)
 	}
-	if got := PermissionSupportOf("dsh"); got != "none" {
-		t.Errorf("PermissionSupportOf(dsh) = %q want none（预设无法表达四档）", got)
+	// 四档走子进程环境变量：dsh 是 profile 启动器，没有逐调用的权限 flag，
+	// shipped 的 sdk profile 直接读 DSH_PERMISSION_MODE（映射见 dshPermissionMode）。
+	if got := PermissionSupportOf("dsh"); got != "env:DSH_PERMISSION_MODE" {
+		t.Errorf("PermissionSupportOf(dsh) = %q want env:DSH_PERMISSION_MODE", got)
 	}
 	if got := AskSupportOf("dsh"); got != "none" {
 		t.Errorf("AskSupportOf(dsh) = %q want none", got)
@@ -326,6 +328,55 @@ func TestDshStreamHeadlessJSONEvents(t *testing.T) {
 	}
 }
 
+// final 为空（本轮没提交正文）时不能把原始 NDJSON 事件流当正文：
+// 用 text 事件累积兜底；连 text 也没有就明确报错。
+func TestDshStreamHeadlessEmptyFinalNeverLeaksEventStream(t *testing.T) {
+	run := func(lines []string) (StreamResult, error) {
+		dir := t.TempDir()
+		body := "case \"$*\" in *--help*) echo 'Usage: dsh --profile headless [--json] [--session-id <id>] [task...]'; exit 0;; esac\n"
+		for _, l := range lines {
+			body += "printf '%s\\n' '" + l + "'\n"
+		}
+		w, _ := argsCaptureCLI(t, dir, "dsh", body)
+		return (&DshEngine{BinPath: w.bin}).Stream(context.Background(), Request{
+			Messages: []Message{{Role: "user", Content: "问"}},
+		}, func(StreamEvent) {})
+	}
+
+	// final 空串 + 有 text 事件 → 正文取 text 累积。
+	res, err := run([]string{
+		`{"type":"session","sessionId":"sess-1","cwd":"/tmp"}`,
+		`{"type":"status","phase":"turn_start","turn":1}`,
+		`{"type":"text","text":"第一段"}`,
+		`{"type":"text","text":"第二段"}`,
+		`{"type":"status","phase":"turn_end","turn":1,"reason":{"kind":"completed"}}`,
+		`{"type":"final","text":""}`,
+	})
+	if err != nil {
+		t.Fatalf("Stream: %v", err)
+	}
+	if res.Response.Text != "第一段第二段" {
+		t.Errorf("Text = %q want 第一段第二段", res.Response.Text)
+	}
+	if strings.Contains(res.Response.Text, `{"type":`) {
+		t.Errorf("正文泄漏了原始事件流：%q", res.Response.Text)
+	}
+
+	// final 空串 + 没有 text 事件 → 报错，正文保持为空（绝不回落 stdout 事件流）。
+	res, err = run([]string{
+		`{"type":"session","sessionId":"sess-1","cwd":"/tmp"}`,
+		`{"type":"thinking","text":"想了想"}`,
+		`{"type":"status","phase":"turn_end","turn":1,"reason":{"kind":"completed"}}`,
+		`{"type":"final","text":""}`,
+	})
+	if err == nil {
+		t.Fatalf("空正文应报错，got Text = %q", res.Response.Text)
+	}
+	if res.Response.Text != "" {
+		t.Errorf("空正文时 Text 应为空，got %q", res.Response.Text)
+	}
+}
+
 // 参数形态：启动器 flag 在前，--session-id / --json 在 app 参数区（headless 自己的 flag）。
 func TestDshHeadlessArgs(t *testing.T) {
 	cases := []struct {

package/internal/agent/engine_test.go

@@ -150,8 +150,8 @@ func TestClaudePassesModelFlag(t *testing.T) {
 	if !strings.Contains(args, "--tools ") {
 		t.Errorf("--tools not passed: %q", args)
 	}
-	if !strings.Contains(args, "--output-format json") {
-		t.Errorf("--output-format json not passed: %q", args)
+	if !strings.Contains(args, "--output-format stream-json") {
+		t.Errorf("--output-format stream-json not passed: %q", args)
 	}
 }
 
@@ -227,17 +227,19 @@ echo '{"type":"result","subtype":"error_max_turns","is_error":true,"result":"超
 	}
 }
 
-func TestClaudeFallbackToRawText(t *testing.T) {
+func TestClaudeRawTextRejected(t *testing.T) {
+	// 协议已全量走 stream-json：没有 result 行的裸文本不再当作正文（旧版回落已删除），
+	// 必须报「协议未跑完」，否则会把 CLI 的报错/日志当成模型答案。
 	cli := writeFakeCLI(t, "claude", "#!/bin/sh\necho 'plain text answer'\n")
 	e := &ClaudeEngine{BinPath: cli}
-	resp, err := e.Complete(context.Background(), Request{
+	_, err := e.Complete(context.Background(), Request{
 		Messages: []Message{{Role: "user", Content: "hi"}},
 	})
-	if err != nil {
-		t.Fatalf("Complete: %v", err)
+	if err == nil {
+		t.Fatal("裸文本（无 result 行）必须报错")
 	}
-	if resp.Text != "plain text answer" {
-		t.Errorf("Text = %q", resp.Text)
+	if !strings.Contains(err.Error(), "stream ended without result line") {
+		t.Errorf("err = %v want stream ended without result line", err)
 	}
 }
 
@@ -314,9 +316,12 @@ exit 0
 	})
 }
 
-func TestCodeBuddyArrayEnvelope(t *testing.T) {
+func TestCodeBuddyResultLineWinsOverAssistant(t *testing.T) {
+	// 协议是逐行 stream-json：assistant 聚合行只是过程快照，全文以 result 行为准。
 	cli := writeFakeCLI(t, "codebuddy", `#!/bin/sh
-echo '[{"type":"system","subtype":"init"},{"type":"assistant","message":{"content":[{"type":"text","text":"部分1"}]}},{"type":"result","result":"最终答案"}]'
+echo '{"type":"system","subtype":"init"}'
+echo '{"type":"assistant","message":{"content":[{"type":"text","text":"部分1"}]}}'
+echo '{"type":"result","result":"最终答案"}'
 `)
 	e := &CodeBuddyEngine{BinPath: cli}
 	resp, err := e.Complete(context.Background(), Request{
@@ -330,9 +335,12 @@ echo '[{"type":"system","subtype":"init"},{"type":"assistant","message":{"conten
 	}
 }
 
-func TestCodeBuddyArrayAssistantFallback(t *testing.T) {
+func TestCodeBuddyEmptyResultFallsBackToDeltas(t *testing.T) {
+	// result 行正文为空时，finalizeStreamText 回落到增量拼接。
 	cli := writeFakeCLI(t, "codebuddy", `#!/bin/sh
-echo '[{"type":"assistant","message":{"content":[{"type":"text","text":"第一段"}]}},{"role":"assistant","content":[{"type":"output_text","text":"第二段"}]}]'
+echo '{"type":"stream_event","event":{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"第一段"}}}'
+echo '{"type":"stream_event","event":{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"第二段"}}}'
+echo '{"type":"result","result":""}'
 `)
 	e := &CodeBuddyEngine{BinPath: cli}
 	resp, err := e.Complete(context.Background(), Request{
@@ -341,14 +349,14 @@ echo '[{"type":"assistant","message":{"content":[{"type":"text","text":"第一
 	if err != nil {
 		t.Fatalf("Complete: %v", err)
 	}
-	if resp.Text != "第一段\n第二段" {
-		t.Errorf("Text = %q want 两段拼接", resp.Text)
+	if resp.Text != "第一段第二段" {
+		t.Errorf("Text = %q want 增量拼接", resp.Text)
 	}
 }
 
 func TestCodeBuddyUserQueryEcho(t *testing.T) {
 	cli := writeFakeCLI(t, "codebuddy", `#!/bin/sh
-echo '<user_query>【系统指令】你是助手</user_query>真正的回答'
+echo '{"type":"result","result":"<user_query>【系统指令】你是助手</user_query>真正的回答"}'
 `)
 	e := &CodeBuddyEngine{BinPath: cli}
 	resp, err := e.Complete(context.Background(), Request{
@@ -363,7 +371,7 @@ echo '<user_query>【系统指令】你是助手</user_query>真正的回答'
 	}
 
 	// 全回显（无闭标签后正文）→ 报错
-	cli2 := writeFakeCLI(t, "codebuddy", "#!/bin/sh\necho '<user_query>只有回显</user_query>'\n")
+	cli2 := writeFakeCLI(t, "codebuddy", "#!/bin/sh\necho '{\"type\":\"result\",\"result\":\"<user_query>只有回显</user_query>\"}'\n")
 	e2 := &CodeBuddyEngine{BinPath: cli2}
 	if _, err := e2.Complete(context.Background(), Request{
 		Messages: []Message{{Role: "user", Content: "hi"}},
@@ -381,9 +389,12 @@ func TestCodeBuddyPassesModel(t *testing.T) {
 		t.Fatal(err)
 	}
 	e := &CodeBuddyEngine{BinPath: cli}
+	// noToolSuffix 只在 off 模式注入（on/白名单下会压制工具调用），
+	// 故这里显式关工具来断言 --append-system-prompt。
 	_, err := e.Complete(context.Background(), Request{
 		Model:    "codebuddy/hy3",
 		Messages: []Message{{Role: "user", Content: "hi"}},
+		Tools:    ToolsOff,
 	})
 	if err != nil {
 		t.Fatalf("Complete: %v", err)
@@ -450,9 +461,12 @@ func TestTraeCompletePlainText(t *testing.T) {
 		t.Fatal(err)
 	}
 	e := &TraeEngine{BinPath: cli}
+	// 工具默认是 on（toolsOrDefault），此处显式关掉以断言 off 模式的
+	// --disallowed-tool 减法与 noToolSuffix。
 	resp, err := e.Complete(context.Background(), Request{
 		Messages: []Message{{Role: "user", Content: "hi"}},
 		Timeout:  90 * time.Second,
+		Tools:    ToolsOff,
 	})
 	if err != nil {
 		t.Fatalf("Complete: %v", err)
@@ -669,10 +683,11 @@ func TestCodeBuddySessionExtract(t *testing.T) {
 	}
 }
 
-// codebuddy 数组形态下 Complete 也要把 session_id 挖出来回传。
-func TestCodeBuddyCompleteExtractsSessionFromArray(t *testing.T) {
+// 只出现在 init 行的 session_id，Complete 也要挖出来回传（续接链路依赖它）。
+func TestCodeBuddyCompleteExtractsSessionFromInitLine(t *testing.T) {
 	cli := writeFakeCLI(t, "codebuddy", `#!/bin/sh
-echo '[{"type":"system","session_id":"cb-init"},{"type":"result","result":"好"}]'
+echo '{"type":"system","session_id":"cb-init"}'
+echo '{"type":"result","result":"好"}'
 `)
 	e := &CodeBuddyEngine{BinPath: cli}
 	resp, err := e.Complete(context.Background(), Request{

package/internal/agent/env_test.go

@@ -99,8 +99,10 @@ func TestEnvDeniedCaseInsensitive(t *testing.T) {
 		"pythonhome":           true,
 		"PATH":                 false,
 		"HOME":                 false,
-		// 仍必须放行：引擎靠它选配置目录（见 codebuddyAccountEnv）
-		"codebuddy_config_dir": false,
+		// CODEBUDDY_* 一刀切剔除（见 env.go 的 codebuddyEnvPrefix）：
+		// 宿主注入的 CONFIG_DIR 会被丢掉，账号隔离需要的值由
+		// codebuddyAccountEnv 经 ChildEnvWith 的 extraEnv 显式补回。
+		"codebuddy_config_dir": true,
 	}
 	for name, want := range cases {
 		if got := envDenied(name); got != want {
@@ -125,15 +127,18 @@ func TestEnvironStripsMixedCaseServerPrefix(t *testing.T) {
 
 func TestEnvDenied(t *testing.T) {
 	cases := map[string]bool{
-		"SERVER__PORT":                true,
-		"SERVER__HOST":                true,
-		"SERVER__ANYTHING":            true,
-		"CODEBUDDY_SESSION_ID":        true,
-		"CODEBUDDY_SERVICE_PROXY_URL": false, // 保留：CLI 可能依赖父会话服务
-		"CODEBUDDY_MCP_CONFIG":        false,
+		"SERVER__PORT":         true,
+		"SERVER__HOST":         true,
+		"SERVER__ANYTHING":     true,
+		"CODEBUDDY_SESSION_ID": true,
+		// CODEBUDDY_* 一律剔除（env.go：宿主注入的 MCP 配置会让 CLI 启动即退）。
+		// 引擎自己需要的 CODEBUDDY_CONFIG_DIR / ACC_PRODUCT_CONFIG_V3 由
+		// codebuddyAccountEnv 通过 extraEnv 重新注入，不靠继承。
+		"CODEBUDDY_SERVICE_PROXY_URL": true,
+		"CODEBUDDY_MCP_CONFIG":        true,
 		"HOME":                        false,
 		"PATH":                        false,
-		"CODEBUDDY_CONFIG_DIR":        false,
+		"CODEBUDDY_CONFIG_DIR":        true,
 	}
 	for name, want := range cases {
 		if got := envDenied(name); got != want {

package/internal/agent/models_test.go

@@ -158,6 +158,9 @@ func TestEngineListModelsWithFakeCLI(t *testing.T) {
 	// 隔离 HOME：codebuddy-ai 的扩展来源会扫 ~/.codebuddy-ai 与 ~/.codebuddy 的
 	// local_storage 缓存，不隔离会吃到真机缓存导致断言失败。
 	t.Setenv("HOME", t.TempDir())
+	// 同一道理，CODEBUDDY_CONFIG_DIR 一设，「只信该目录」的规则就生效，
+	// 本用例凭空搭的 HOME 缓存被绕过（见 TestCodeBuddyListModelsProductJSON 的注释）。
+	t.Setenv("CODEBUDDY_CONFIG_DIR", "")
 	cases := []struct {
 		name    string
 		cliName string
@@ -486,6 +489,12 @@ func TestCodeBuddyListModelsAccConfig(t *testing.T) {
 func TestCodeBuddyListModelsProductJSON(t *testing.T) {
 	// 隔离 HOME：扩展来源扫 ~/.codebuddy-ai 与 ~/.codebuddy 的缓存，不隔离会吃到真机缓存。
 	t.Setenv("HOME", t.TempDir())
+	/* 还要清 CODEBUDDY_CONFIG_DIR：用户显式设了它时，`codebuddyModelCacheDirs` 只返回
+	   该目录下的 local_storage、**不再兜底共享 ~/.codebuddy**（产品行为是对的：显式
+	   配置就该独占）。但本用例全程用 HOME 凭空搭缓存，环境里一带这个变量，B/D2 段
+	   写的缓存就永远读不到，表现为「ai 只剩 product.json 的 4 条」「workbuddy ② 退回
+	   --help」。实测本机 shell 就带着它（2026-10-21 定位，与代码无关）。 */
+	t.Setenv("CODEBUDDY_CONFIG_DIR", "")
 
 	const aiHelp = `Options:
   --model <model>  Model ID. Currently supported: (fast-model, balanced-model, primary-model, deep-model)

package/internal/agent/runcmd_test.go

@@ -27,11 +27,32 @@ func TestRunCLIKillsProcessGroupOnTimeout(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
+	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	done := make(chan error, 1)
+	go func() {
+		_, _, err := runCLI(ctx, cli)
+		done <- err
+	}()
+
+	// 先等 worker 真起来再触发取消：整包并发跑时 sh 启动可能慢于固定
+	// 超时窗口，直接按 800ms 计时会假红（marker 还没建就被杀了）。
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		if _, err := os.Stat(marker); err == nil {
+			break
+		}
+		if time.Now().After(deadline) {
+			cancel()
+			<-done
+			t.Fatal("marker should exist (worker never started)")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
 	start := time.Now()
-	_, _, err := runCLI(ctx, cli)
-	if err == nil {
+	cancel()
+	if err := <-done; err == nil {
 		t.Fatal("expected timeout error")
 	}
 	if elapsed := time.Since(start); elapsed > 5*time.Second {

package/internal/agent/stream.go

@@ -137,6 +137,19 @@ const (
 	// 是 item 生命周期，这里对齐的是渲染词表。前端 09 的 case "command" 用终端
 	// 图标（SquareTerminal）渲染标记行。
 	KindCommand StreamEventKind = "command"
+	// KindTasks 团队任务列表快照（2026-10-22）：一张卡列出全部子任务 + 每行状态。
+	//
+	// Text 是 JSON（快照语义，每次任一子任务状态变化就整份重发）：
+	//
+	//	{"tasks":[{"id","title","role","kind","engine","model",
+	//	           "status","deps","note","session_id","run_id","output"}]}
+	//
+	// status 词表 pending / running / done / failed / skipped，渲染层映射成
+	// in_progress / completed / failed。
+	//
+	// 为什么不再走「每个子任务一张委派卡」：子任务已经是**独立会话**
+	//（2026-10-22 用户定稿），过程在自己的会话里看；主会话只需要一张进度总览。
+	KindTasks StreamEventKind = "tasks"
 )
 
 // StreamStatus 事件所描述的 item 状态 —— 对齐 agents-anywhere 的
@@ -172,6 +185,12 @@ type StreamEvent struct {
 	// 落库/绑定 —— 否则下一轮追问会找不到锚点，只能退化成 `-c` 续接最近会话。
 	// 引擎在每轮 result 行就能拿到 session_id（claude/codebuddy 的收尾行自带）。
 	SessionID string
+	// SubSessionID 子会话 id（团队模式）：这条事件所属**子任务**自己的引擎会话 id。
+	//
+	// 2026-10-22 起子任务是独立会话：它的事件写进**自己的**日志，SessionID 就是
+	// 子会话锚点，不再抹掉。这个字段只在主会话里出现 —— 任务列表卡用它把某一行
+	// 链到对应子会话（历史回放同样靠它复原链接）。
+	SubSessionID string
 	// Ask 归一化后的「需要用户选择」请求（仅 KindAsk 携带；其余为 nil）。
 	//
 	// 有了它，调用方不必再分辨这次是 claude 的 tool_use 形态还是 control_request 形态
@@ -229,6 +248,20 @@ type StreamEvent struct {
 	// Reason 根因摘要（仅 KindTurnFailed 携带），与 -o json 的失败 envelope 同源
 	//（同走 agent.ReasonOf），同一次失败在事件流与 stderr 两处的说法必然一致。
 	Reason string
+
+	/* Parent 父委派 id（2026-10-21，团队模式）。
+	 *
+	 * 语义与 claude 系原生的 `parent_tool_use_id` 完全一致：非空表示「这条事件发生在
+	 * id 为 Parent 的委派卡里面」。客户端画布据此把思考 / 正文 / 工具事件挂进父卡的
+	 * 嵌套区（见 client-ui/shared/conv/09-stream-apply.js 的 evParent 分支）。
+	 *
+	 * ⚠️ 2026-10-22 起团队模式**不再**用它：子任务是独立会话，各自的事件写进自己的
+	 * 日志，主会话只发 KindTasks 快照。字段保留给引擎原生的子代理委派（claude 的
+	 * parent_tool_use_id）与旧日志回放。
+	 *
+	 * 空串 = 主会话自己的事件（omitempty，老消费者字段集不变）。
+	 */
+	Parent string
 }
 
 // ToolCall 一次完整的工具调用记录（用于收尾汇总）。