magic-agent 2.4.3 → 2.6.0

package/internal/agent/models.go

@@ -11,7 +11,7 @@ package agent
 //	codebuddy 扩展来源链（两端同链 ③）：客户端合并配置缓存 acc-product-config
 //	          → 远程配置缓存 ∪ App 包 product.json → `codebuddy --help` 的
 //	          "Currently supported: (...)" 清单（末级兜底）
-//	trae      `trae-cli models --json`
+//	trae      `traex models --json`
 //	llm       `llm models`（用户经 llm CLI 自注册的模型）
 //	codex     `codex debug models`（raw model catalog）
 //	openclaw  `openclaw models list --json`
@@ -94,6 +94,22 @@ func ModelCreditListOf(e Engine) ModelCreditLister {
 	return l
 }
 
+// ModelVendorLister 可选接口：引擎能给出各模型的**供应商展示名**
+// （只用于选择器的第二行，不参与 -m / 落库）。键与 ListModels 的模型 id 同形；
+// 拿不到（或引擎不提供）返回 nil —— 界面不显示第二行。
+//
+// 现状只有 codebuddy 系实现：值取自它自己 models.json 里 `vendor` 字段
+// （空 / "Custom" 这类无信息量的值会被过滤，见 CLIModelVendors）。
+type ModelVendorLister interface {
+	ModelVendors(ctx context.Context) map[string]string
+}
+
+// ModelVendorListOf 返回引擎的 ModelVendorLister 实现（未实现返回 nil）。
+func ModelVendorListOf(e Engine) ModelVendorLister {
+	l, _ := e.(ModelVendorLister)
+	return l
+}
+
 // parseCreditMultiplier 把客户端计费字段规范化成纯倍率数字字符串：
 //
 //	"x2.20 credits" -> "2.20"    "x0.77" -> "0.77"    "  X1.5 CREDITS " -> "1.5"
@@ -511,6 +527,42 @@ func remoteConfigCacheCatalog(localStorageDir string) ([]string, map[string]stri
 	return ids, credits
 }
 
+// remoteCacheCatalogWithSelector 用「本账号 CLI 自己下发的远程配置缓存」当注册表，
+// 并用**同一目录**里的客户端选择器清单（agents[].models）过滤，产出与 acc 缓存
+// 同语义的模型清单 + 倍率表。
+//
+// 为什么需要它：codebuddy-ai 的账号已与桌面 App 物理隔离（独立 homedir），App 的
+// acc 缓存（~/.workbuddy-ai）属于另一个账号、只有 5 条模型，会把清单钉死在 2 个
+// custom-local。隔离后的引擎应改用 CLI 自己拉到的配置（<config_dir>/local_storage）。
+//
+// 过滤语义与 readAccCatalog 一致：custom-local:* 一律保留（客户端也展示，只是不计
+// 倍率），具名模型只在选择器清单里才展示；缓存里没有选择器清单时不过滤（宁可多不可少）。
+func remoteCacheCatalogWithSelector(localStorageDir string) ([]string, map[string]string) {
+	ids, credits := remoteConfigCacheCatalog(localStorageDir)
+	if len(ids) == 0 {
+		return nil, nil
+	}
+	allow, ok := agentSelectorModels(localStorageDir)
+	if !ok || len(allow) == 0 {
+		return ids, credits
+	}
+	on := make(map[string]bool, len(allow))
+	for _, id := range allow {
+		on[id] = true
+	}
+	kept := make([]string, 0, len(ids))
+	for _, id := range ids {
+		if strings.HasPrefix(id, "custom-local:") || on[id] {
+			kept = append(kept, id)
+		}
+	}
+	if len(kept) == 0 {
+		// 选择器清单与注册表完全对不上（配置漂移）：退回全量，别给出空清单。
+		return ids, credits
+	}
+	return kept, credits
+}
+
 // agentSelectorModels 从远程配置缓存里抽**客户端模型选择器真正展示的清单**
 // —— agents[].models 数组：
 //

package/internal/agent/models_test.go

@@ -157,7 +157,10 @@ func TestJSONModelsArray(t *testing.T) {
 func TestEngineListModelsWithFakeCLI(t *testing.T) {
 	// 隔离 HOME：codebuddy-ai 的扩展来源会扫 ~/.codebuddy-ai 与 ~/.codebuddy 的
 	// local_storage 缓存，不隔离会吃到真机缓存导致断言失败。
-	t.Setenv("HOME", t.TempDir())
+	// Windows 上 os.UserHomeDir() 读 USERPROFILE，两者都要设。
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
 	// 同一道理，CODEBUDDY_CONFIG_DIR 一设，「只信该目录」的规则就生效，
 	// 本用例凭空搭的 HOME 缓存被绕过（见 TestCodeBuddyListModelsProductJSON 的注释）。
 	t.Setenv("CODEBUDDY_CONFIG_DIR", "")
@@ -242,7 +245,9 @@ func TestEngineListModelsWithFakeCLI(t *testing.T) {
 func TestEngineListModelsFailures(t *testing.T) {
 	// 隔离 HOME 与配置目录：codebuddy 的清单现在先读扩展来源（acc 缓存 /
 	// 远程配置缓存），不隔离会吃到真机的 ~/.workbuddy 缓存而"意外成功"。
-	t.Setenv("HOME", t.TempDir())
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home) // Windows: os.UserHomeDir 读 USERPROFILE
 	t.Setenv("CODEBUDDY_CONFIG_DIR", filepath.Join(t.TempDir(), "cfg"))
 
 	// 三级来源全空、--help 里也没有 "Currently supported" → ErrNoModelSource 语义的错误。
@@ -389,7 +394,10 @@ func TestReadRemoteConfigCacheModels(t *testing.T) {
 // codebuddy-ai 首选 ~/.workbuddy-ai/cache/acc-product-config-v*.json（客户端模型
 // 选择器同源）；多版本取 mtime 最新；缺失时回退「远程配置缓存 ∪ product.json」。
 func TestCodeBuddyListModelsAccConfig(t *testing.T) {
-	t.Setenv("HOME", t.TempDir())
+	home := t.TempDir()
+	// Windows 上 os.UserHomeDir() 读 USERPROFILE，只设 HOME 隔离不住真机缓存。
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
 	cacheDir := filepath.Join(os.Getenv("HOME"), ".workbuddy-ai", "cache")
 	if err := os.MkdirAll(cacheDir, 0o755); err != nil {
 		t.Fatal(err)
@@ -488,7 +496,10 @@ func TestCodeBuddyListModelsAccConfig(t *testing.T) {
 // 2026-09-28 起 codebuddy（WorkBuddy 端）也启用扩展链，故 D 段与 AI 端同构。
 func TestCodeBuddyListModelsProductJSON(t *testing.T) {
 	// 隔离 HOME：扩展来源扫 ~/.codebuddy-ai 与 ~/.codebuddy 的缓存，不隔离会吃到真机缓存。
-	t.Setenv("HOME", t.TempDir())
+	// Windows 上 os.UserHomeDir() 读 USERPROFILE，两者都要设。
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
 	/* 还要清 CODEBUDDY_CONFIG_DIR：用户显式设了它时，`codebuddyModelCacheDirs` 只返回
 	   该目录下的 local_storage、**不再兜底共享 ~/.codebuddy**（产品行为是对的：显式
 	   配置就该独占）。但本用例全程用 HOME 凭空搭缓存，环境里一带这个变量，B/D2 段
@@ -646,7 +657,10 @@ func TestCodeBuddyListModelsProductJSON(t *testing.T) {
 // 此前它只按 --help 出清单、倍率却按 acc 缓存取，同一引擎两个字段读自两个文件）。
 // 同时验证清单与倍率全程不启动 CLI（acc 命中时只读缓存文件）。
 func TestCodeBuddyModelCredits(t *testing.T) {
-	t.Setenv("HOME", t.TempDir())
+	home := t.TempDir()
+	// Windows 上 os.UserHomeDir() 读 USERPROFILE，只设 HOME 隔离不住真机缓存。
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
 	t.Setenv("CODEBUDDY_CONFIG_DIR", "")
 
 	const help = `Options:
@@ -777,6 +791,7 @@ func appPkgCLI(t *testing.T, helpOut, productJSON string) (bin, argsLog string)
 func TestClaudeListModelsFromConfig(t *testing.T) {
 	home := t.TempDir()
 	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home) // Windows: os.UserHomeDir 读 USERPROFILE
 	t.Setenv("CLAUDE_CONFIG_DIR", "")
 
 	dir := filepath.Join(home, ".claude")

package/internal/agent/pidalive_windows_test.go

@@ -0,0 +1,40 @@
+//go:build windows
+
+package agent
+
+import (
+	"os"
+	"testing"
+	"time"
+)
+
+// PIDAlive 的两条硬要求（2026-10-24「返回会话列表很忙」的回归闸门）：
+//
+//	① 判得准：自己活着、不存在的 pid 说不在；
+//	② **不许起子进程** —— 原实现 `tasklist /FI "PID eq N"` 本机实测每次 6.7–7.5 秒，
+//	   `--sessions` 对每条活着的记录问一次 ⇒ 列表 5–10 秒。这里用 50 次调用的总耗时
+//	   卡住回归：走 OpenProcess 是微秒级，一旦退回起进程，这条会**红**（而不是悄悄变慢）。
+func TestPIDAliveSelfAndBogus(t *testing.T) {
+	if !PIDAlive(os.Getpid()) {
+		t.Fatal("自己的 pid 应判为活着")
+	}
+	if PIDAlive(1 << 30) {
+		t.Fatal("不存在的 pid 应判为不在")
+	}
+	if PIDAlive(0) || PIDAlive(-1) {
+		t.Fatal("非正 pid 应判为不在")
+	}
+}
+
+func TestPIDAliveIsFast(t *testing.T) {
+	self := os.Getpid()
+	st := time.Now()
+	for i := 0; i < 50; i++ {
+		if !PIDAlive(self) {
+			t.Fatal("自己的 pid 应判为活着")
+		}
+	}
+	if d := time.Since(st); d > 2*time.Second {
+		t.Fatalf("50 次 PIDAlive 用了 %v —— 又回到起子进程（tasklist）的实现了吗？", d)
+	}
+}

package/internal/agent/runcmd.go

@@ -51,6 +51,22 @@ func notifySpawn(ctx context.Context, pid int) {
 	}
 }
 
+// ConfigureProcGroup 让子进程进入**独立进程组**（供本仓之外的调用方使用）。
+//
+// 目前是 internal/client 的脚本管理（见 scripts.go）：脚本被启动后要能被
+// **整组**停掉 —— unix 上 kill(-pid) 一把带走全部后代，Windows 上 taskkill /T
+// 带走整棵进程树。若不设这一层，脚本 spawn 出来的 worker 会变孤儿进程，
+// 停脚本只停掉了壳。
+//
+// 各平台的实现分别在 runcmd_unix.go（Setpgid）与 runcmd_windows.go
+// （CREATE_NEW_PROCESS_GROUP）。
+func ConfigureProcGroup(cmd *exec.Cmd) {
+	if cmd == nil {
+		return
+	}
+	configureProcAttr(cmd)
+}
+
 // runCLI 在独立进程组里执行 bin args，返回 (stdout, stderr, err)。
 // 超时/取消时杀掉整个进程组（含 CLI 的全部后代进程）。
 func runCLI(ctx context.Context, bin string, args ...string) (string, string, error) {
@@ -73,6 +89,13 @@ func runCLIEnv(ctx context.Context, extra []string, bin string, args ...string)
 
 // runCLIEnvIn = runCLIIn + runCLIEnv（工作目录 + 追加环境变量）。
 func runCLIEnvIn(ctx context.Context, dir string, extra []string, bin string, args ...string) (string, string, error) {
+	return runCLIEnvInStdin(ctx, dir, extra, "", bin, args...)
+}
+
+// runCLIEnvInStdin 同 runCLIEnvIn，额外把 stdinText 喂给子进程 stdin（空 = 保持旧行为，
+// stdin 是空的）。dsh 的 headless 在 Windows 上只能用这条路传多行提示词（见 dsh.go::
+// dshHeadlessPromptArg），其它引擎都不用。
+func runCLIEnvInStdin(ctx context.Context, dir string, extra []string, stdinText, bin string, args ...string) (string, string, error) {
 	// launchWrap 与流式路径同源：.cmd/.bat 在 Windows 上不能直接 exec，
 	// 参数会被 cmd.exe 拆坏（实测含换行的提示词整段丢失）。unix 上原样透传。
 	spec := launchWrap(bin, args)
@@ -80,6 +103,9 @@ func runCLIEnvIn(ctx context.Context, dir string, extra []string, bin string, ar
 	if dir != "" {
 		cmd.Dir = dir
 	}
+	if stdinText != "" {
+		cmd.Stdin = strings.NewReader(stdinText)
+	}
 	configureProcAttr(cmd)
 
 	/* stdout/stderr 用**自建管道 + 自己 drain**，不直挂 bytes.Buffer：

package/internal/agent/runcmd_windows.go

@@ -16,8 +16,8 @@ import (
 	"errors"
 	"os/exec"
 	"strconv"
-	"strings"
 	"syscall"
+	"unsafe"
 )
 
 // createNewProcessGroup 对应 Windows CREATE_NEW_PROCESS_GROUP 标志。
@@ -53,14 +53,45 @@ func KillPID(pid int, group bool) error {
 	return exec.Command("taskkill", "/T", "/F", "/PID", strconv.Itoa(pid)).Run()
 }
 
-// PIDAlive 用 tasklist 查该 pid 是否还在。
+/*
+── PIDAlive：直接问内核，**绝不起子进程** ──
+
+	2026-10-24 实测：原来的 `tasklist /FI "PID eq N"` 每次要 **6.7–7.5 秒**
+	（控制台进程 + Defender 扫描）。而 `--sessions` 会对每条**活着的**记录问一次
+	（normalizeDead）——有团队任务在跑时就是 5–10 秒，手机端「返回会话列表很忙」
+	的真正根因（插件侧 exec 的 3 秒是另一层，见 client/corecmd.go）。
+	OpenProcess + GetExitCodeProcess 是纯内核调用，微秒级。
+*/
+var (
+	kernel32               = syscall.NewLazyDLL("kernel32.dll")
+	procOpenProcess        = kernel32.NewProc("OpenProcess")
+	procGetExitCodeProcess = kernel32.NewProc("GetExitCodeProcess")
+)
+
+const (
+	// processQueryLimitedInformation 只要查询权限（Vista+），比 QUERY_INFORMATION 更容易拿到。
+	processQueryLimitedInformation = 0x1000
+	// stillActive STILL_ACTIVE：进程还活着时 GetExitCodeProcess 返回它。
+	stillActive = 259
+	// errorAccessDenied 打不开句柄（受保护 / 提权进程）：进程**存在**，但查不了状态。
+	errorAccessDenied = syscall.Errno(5)
+)
+
+// PIDAlive 该 pid 是否还在（OpenProcess / GetExitCodeProcess，无子进程）。
 func PIDAlive(pid int) bool {
 	if pid <= 0 {
 		return false
 	}
-	out, err := exec.Command("tasklist", "/FI", "PID eq "+strconv.Itoa(pid), "/NH").Output()
-	if err != nil {
+	h, _, callErr := procOpenProcess.Call(uintptr(processQueryLimitedInformation), 0, uintptr(pid))
+	if h == 0 {
+		/* 打不开：ACCESS_DENIED 说明进程在（只是权限不够）→ 当活着，
+		   避免把受保护进程误判成 gone；其它错误（INVALID_PARAMETER）才是真没了。 */
+		return errors.Is(callErr, errorAccessDenied)
+	}
+	defer func() { _ = syscall.CloseHandle(syscall.Handle(h)) }()
+	var code uint32
+	if r, _, _ := procGetExitCodeProcess.Call(h, uintptr(unsafe.Pointer(&code))); r == 0 {
 		return false
 	}
-	return strings.Contains(string(out), strconv.Itoa(pid))
+	return code == stillActive
 }

package/internal/agent/stream.go

@@ -27,11 +27,9 @@ package agent
 //	  收尾 {"type":"result","subtype":"success","result":"全文",...}
 //
 //	trae：
-//	  -p --output-format stream-json --include-partial-messages
-//	  NDJSON 行 {"type":"stream_event","delta":{"role":"assistant",
-//	  "content":"增量"}}；无 thinking 通道（模型侧不开 reasoning）；
-//	  trae 的 stream-json 协议**不暴露独立工具事件通道**，KindToolUse/KindToolResult
-//	  在 trae 下恒为空——这是协议限制，不是解析缺陷。
+//	  traex exec --json，Codex 同源事件流（thread.started / item.* /
+//	  turn.completed），解析在 trae_exec.go；正文、思考与工具都在 item 事件里。
+//	  无逐 token 正文增量：正文在 item.completed(agent_message) 整段给出。
 
 import (
 	"bufio"
@@ -150,6 +148,15 @@ const (
 	// 为什么不再走「每个子任务一张委派卡」：子任务已经是**独立会话**
 	//（2026-10-22 用户定稿），过程在自己的会话里看；主会话只需要一张进度总览。
 	KindTasks StreamEventKind = "tasks"
+	// KindFallback 主备降级（2026-10-26）：主引擎失败 / 只有过程没有正文，本轮已由
+	// 备用引擎（或同引擎的备用模型）接上。StreamEvent.Fallback 带 from/to 两端。
+	//
+	// 为什么要有它：以前降级只发一条 notice（人话一行），客户端无法**结构化地**知道
+	// 「这条回答其实是我的备用模型给的」—— 额度用尽时用户配的主备是否真的生效，
+	// 界面上没有任何可认的证据（2026-10-26 报障：「主备模型还没真的发挥作用」，
+	// 作业记录里主备两条都配了、却查不到降级发生过没有）。
+	// 这条帧紧跟降级之后、备用引擎第一条事件之前；没降级时的原因走 `notice`。
+	KindFallback StreamEventKind = "fallback"
 )
 
 // StreamStatus 事件所描述的 item 状态 —— 对齐 agents-anywhere 的
@@ -196,6 +203,8 @@ type StreamEvent struct {
 	// 有了它，调用方不必再分辨这次是 claude 的 tool_use 形态还是 control_request 形态
 	//（两种形态在 wire 上字段完全不同，见 ask.go 的 ParseAskLine）。
 	Ask *AskRequest
+	// Fallback 降级详情（仅 KindFallback 携带；其余为 nil）。
+	Fallback *FallbackEvent
 
 	/* ── 状态收敛字段（2026-10-02，对齐 agents-anywhere 的 timeline item）──
 	 *
@@ -312,7 +321,8 @@ func streamArgsFor(e Engine) []string {
 	case *CodeBuddyAIEngine:
 		return []string{"stream-json"}
 	case *TraeEngine:
-		return []string{"stream-json"}
+		// Codex 同源的 `exec --json` JSONL 事件流（trae_exec.go）。
+		return []string{"jsonl"}
 	case *LLMEngine:
 		return []string{"stream"} // llm prompt 默认流式（纯文本 stdout）
 	case *DshEngine:
@@ -526,10 +536,19 @@ func runStreamCLIStdinReaderIn(ctx context.Context, dir string, extraEnv []strin
 // extraEnv 追加到继承环境之后（重复 key 取后者）—— dsh 的权限档位就是这么下发的
 // （它没有逐调用的权限 flag，只有 DSH_PERMISSION_MODE，见 permission.go）。
 func runStreamLinesIn(ctx context.Context, dir string, extraEnv []string, bin string, args []string, streamStdout bool, onLine func(line string) error) (string, string, error) {
+	return runStreamLinesInStdin(ctx, dir, extraEnv, "", bin, args, streamStdout, onLine)
+}
+
+// runStreamLinesInStdin 同 runStreamLinesIn，额外把 stdinText 喂给子进程 stdin
+// （空 = 旧行为）。dsh headless 在 Windows 上靠它传多行提示词，见 dshHeadlessPromptArg。
+func runStreamLinesInStdin(ctx context.Context, dir string, extraEnv []string, stdinText, bin string, args []string, streamStdout bool, onLine func(line string) error) (string, string, error) {
 	cmd := newStreamCmdIn(dir, bin, args)
 	if len(extraEnv) > 0 {
 		cmd.Env = append(cmd.Env, extraEnv...)
 	}
+	if stdinText != "" {
+		cmd.Stdin = strings.NewReader(stdinText)
+	}
 
 	stdoutR, stdoutW, err := os.Pipe()
 	if err != nil {
@@ -748,6 +767,12 @@ type streamAccumulator struct {
 	// 万一引擎推了多条 max_tokens 也只报一次（与 askSeen / imgSeen 同一手法）。
 	maxTokensNoticed bool
 
+	// toolMissingSeen 已提示过「工具不在当前工具集」的工具名（2026-10-24）。
+	//
+	// 同一句 CLI 错误可能走多条路各出现一次（增量 delta + assistant 聚合行 +
+	// result 行），提示只该出现一次 —— 与 askSeen / imgSeen 同一手法。
+	toolMissingSeen map[string]bool
+
 	/* ── 状态收敛状态机（2026-10-02，见 StreamEvent 的状态收敛字段注释）──
 	 *
 	 * agents-anywhere 的 ClaudeStreamAccumulator（runtimes/claude/timeline/stream.py）
@@ -931,6 +956,16 @@ func (a *streamAccumulator) emitTextDelta(index int, kind StreamEventKind, text
 	if text == "" {
 		return
 	}
+	/* 「工具不存在」是 CLI 注入的**正文**（见 stripToolMissingLines 的说明）：
+	   摘掉并改发过程提示，别让一句英文报错混进回答。 */
+	if kind == KindText {
+		var missing []string
+		text, missing = stripToolMissingLines(text)
+		a.noteToolMissing(missing)
+		if text == "" {
+			return
+		}
+	}
 	if a.textBlocks == nil {
 		a.textBlocks = make(map[int]string)
 	}
@@ -964,6 +999,15 @@ func (a *streamAccumulator) emitTextDelta(index int, kind StreamEventKind, text
 // 所以先与已累积正文做前缀比对：完全一致静默收敛、多尾巴只补差量。
 // 旧版 CLI（聚合行是正文唯一来源）行为不变：accumulated 为空时原样发。
 func (a *streamAccumulator) emitAggregateText(full string) {
+	if full == "" {
+		return
+	}
+	/* 过滤必须放在**前缀比对之前**：聚合行是整条消息全文，若把错误行留在
+	   里面，与已发增量（已过滤）永远对不上 → 走 default 分支整段重发，
+	   正文里又会多出一份全文。 */
+	var missing []string
+	full, missing = stripToolMissingLines(full)
+	a.noteToolMissing(missing)
 	if full == "" {
 		return
 	}
@@ -1408,6 +1452,88 @@ func extractToolResultText(raw json.RawMessage) string {
 	return ""
 }
 
+/* ── 「工具不在当前工具集」的 CLI 错误行（2026-10-24）──────────────
+ *
+ * 现象（真机抓包，codebuddy + hy3）：模型凭训练记忆调用 AskUserQuestion，
+ * codebuddy CLI 没有这个工具，于是把错误当成**正文 text 块**推回来：
+ *
+ *	{"type":"assistant","message":{"content":[{"type":"text",
+ *	  "text":"Tool \"AskUserQuestion\" does not exist in the current tool set."}]}}
+ *
+ * 不处理的话这句话被拼进正文（用户看到「一段回答中间夹着这句英文」），
+ * 历史回放同样脏。这里把它从正文里摘掉，改发一条 KindNotice（工具失败提示），
+ * 正文只留模型真正说的话。
+ *
+ * 只认这一句固定模板（CLI 自己注入的错误，不可能是模型正文）；模型正常讨论
+ * 工具时不会逐字写成这个形状。 */
+const (
+	toolMissingPrefix = `Tool "`
+	toolMissingSuffix = ` does not exist in the current tool set.`
+)
+
+// stripToolMissingLines 从正文里摘掉 CLI 注入的「工具不存在」错误行。
+// 返回清洗后的正文与被摘掉的工具名（调用方据此发提示）。
+func stripToolMissingLines(s string) (string, []string) {
+	if !strings.Contains(s, toolMissingPrefix) {
+		return s, nil
+	}
+	var (
+		b     strings.Builder
+		tools []string
+	)
+	for {
+		i := strings.Index(s, toolMissingPrefix)
+		if i < 0 {
+			break
+		}
+		rest := s[i+len(toolMissingPrefix):]
+		j := strings.IndexByte(rest, '"')
+		if j <= 0 {
+			break
+		}
+		name := rest[:j]
+		after := rest[j+1:]
+		if !strings.HasPrefix(after, toolMissingSuffix) {
+			// 只是正文里恰好出现了同样的开头 → 原样留下，继续往后找。
+			b.WriteString(s[:i+len(toolMissingPrefix)])
+			s = rest
+			continue
+		}
+		b.WriteString(s[:i])
+		tools = append(tools, name)
+		s = after[len(toolMissingSuffix):]
+		// 摘掉整行：两侧各吞掉一个换行，避免正文里多出空行。
+		left := b.String()
+		if strings.HasSuffix(left, "\n") && strings.HasPrefix(s, "\n") {
+			s = s[1:]
+		}
+	}
+	b.WriteString(s)
+	if len(tools) == 0 {
+		// 只是正文里出现了同样的开头：原样返回（b 就是原文，不能返回被
+		// 拆过的 s —— 那会丢掉前面已写进 b 的部分）。
+		return b.String(), nil
+	}
+	return strings.Trim(b.String(), "\n"), tools
+}
+
+// noteToolMissing 为被摘掉的错误行发一条过程提示（同一工具名只报一次）。
+func (a *streamAccumulator) noteToolMissing(names []string) {
+	if len(names) == 0 {
+		return
+	}
+	if a.toolMissingSeen == nil {
+		a.toolMissingSeen = make(map[string]bool)
+	}
+	for _, n := range names {
+		if a.toolMissingSeen[n] {
+			continue
+		}
+		a.toolMissingSeen[n] = true
+		a.emit(KindNotice, fmt.Sprintf("工具 %q 不在当前工具集，本次调用已忽略", n))
+	}
+}
+
 // assistantLineText 从 assistant 聚合行里取出纯文本正文。
 //
 // 行形状（claude / codebuddy 同族）：
@@ -1551,6 +1677,10 @@ func (a *streamAccumulator) emitTurnEnd(text, sessionID string) {
 	if a.OnEvent == nil {
 		return
 	}
+	// result 行也可能带着同一条 CLI 错误（与增量路重复出现时 noteToolMissing 去重）。
+	var missing []string
+	text, missing = stripToolMissingLines(text)
+	a.noteToolMissing(missing)
 	if a.SanitizeTurnText != nil {
 		text = a.SanitizeTurnText(text)
 	}

package/internal/agent/stream_test.go

@@ -5,7 +5,7 @@ package agent
 // 用 fake CLI 脚本回放三家 CLI 的真实 NDJSON 样本（2026-09-15 实测抓包），
 // 验证：
 //	- claude/codebuddy：thinking_delta / text_delta 解析与转发
-//	- trae：delta.content 直出增量解析
+//	- trae 2.0：exec --json 的 JSONL（reasoning / command_execution / agent_message）
 //	- result 收尾行：全文以 result.result 为准
 //	- 流中断（无 result 行）→ 报错
 //	- 超时杀进程组
@@ -150,14 +150,16 @@ echo '{"type":"result","subtype":"success","is_error":false,"result":"<user_quer
 
 // ── trae 流式 ─────────────────────────────────────────────────
 
-func TestTraeStreamParsesDeltaContent(t *testing.T) {
-	// 样本精简自真实抓包：delta.content 直出，无 thinking 通道。
+func TestTraeStreamExecJSON(t *testing.T) {
+	// 2.0：Codex 同源 JSONL（reasoning / command_execution / agent_message）。
 	cli := writeFakeCLI(t, "trae-cli", `#!/bin/sh
-echo '{"type":"system","subtype":"init","session_id":"t-1"}'
-echo '{"type":"stream_event","session_id":"t-1","delta":{"role":"assistant","content":"2"}}'
-echo '{"type":"stream_event","session_id":"t-1","delta":{"role":"assistant","content":"就是这个"}}'
-echo '{"type":"assistant","session_id":"t-1","message":{"role":"assistant","content":"2就是这个"}}'
-echo '{"type":"result","subtype":"success","session_id":"t-1","result":"2就是这个","is_error":false}'
+printf '%s\n' '{"type":"thread.started","thread_id":"t-1"}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"r","type":"reasoning","text":"想"}}'
+printf '%s\n' '{"type":"item.started","item":{"id":"c","type":"command_execution","command":"ls"}}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"c","type":"command_execution","command":"ls","aggregated_output":"a.txt"}}'
+printf '%s\n' '{"type":"item.updated","item":{"id":"m","type":"agent_message","text":"2"}}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"m","type":"agent_message","text":"2就是这个"}}'
+printf '%s\n' '{"type":"turn.completed"}'
 `)
 	e := &TraeEngine{BinPath: cli}
 	events, onEvent := collectEvents()
@@ -171,11 +173,20 @@ echo '{"type":"result","subtype":"success","session_id":"t-1","result":"2就是
 	if res.Text != "2就是这个" {
 		t.Errorf("Text = %q", res.Text)
 	}
-	if res.Thinking != "" {
-		t.Errorf("trae 无 thinking 通道，Thinking 应为空，got %q", res.Thinking)
+	if res.Thinking != "想" {
+		t.Errorf("Thinking = %q want 想", res.Thinking)
 	}
-	if len(*events) != 2 {
-		t.Errorf("events = %d, want 2（assistant 聚合行不重复 emit）", len(*events))
+	if res.SessionID != "t-1" {
+		t.Errorf("SessionID = %q want t-1", res.SessionID)
+	}
+	wantKinds := []StreamEventKind{KindThinking, KindToolUse, KindToolResult, KindText, KindText, KindTurnEnd}
+	if len(*events) != len(wantKinds) {
+		t.Fatalf("events = %d want %d: %+v", len(*events), len(wantKinds), *events)
+	}
+	for i, want := range wantKinds {
+		if (*events)[i].Kind != want {
+			t.Errorf("events[%d] = %v want %v", i, (*events)[i].Kind, want)
+		}
 	}
 }
 
@@ -385,32 +396,8 @@ echo '{"type":"result","subtype":"success","is_error":false,"result":"ok"}'
 	}
 }
 
-// trae 协议不暴露工具事件：即使用户开了 --tools on，流式输出也不带工具事件。
-// 这是协议限制，不是解析缺陷。
-func TestTraeStreamNoToolEvents(t *testing.T) {
-	cli := writeFakeCLI(t, "trae-cli", `#!/bin/sh
-echo '{"type":"stream_event","delta":{"role":"assistant","content":"正文"}}'
-echo '{"type":"result","subtype":"success","is_error":false,"result":"正文"}'
-`)
-	e := &TraeEngine{BinPath: cli}
-	events, onEvent := collectEvents()
-
-	res, err := e.Stream(context.Background(), Request{
-		Messages: []Message{{Role: "user", Content: "hi"}},
-	}, onEvent)
-	if err != nil {
-		t.Fatalf("Stream: %v", err)
-	}
-
-	for _, ev := range *events {
-		if ev.Kind == KindToolUse || ev.Kind == KindToolResult {
-			t.Errorf("trae 不应发射工具事件, got %v", ev.Kind)
-		}
-	}
-	if len(res.Tools) != 0 {
-		t.Errorf("trae res.Tools 应为 nil/空, got %d", len(res.Tools))
-	}
-}
+// trae 2.0 的工具事件由 TestTraeStreamExecJSON 覆盖（command_execution →
+// tool_use/tool_result）；这里不再保留 1.x「协议不暴露工具」的旧断言。
 
 // 协议异常：open tool_use 没收到 stop 直接来 result → 兜底回收，不丢事件。
 func TestClaudeStreamToolUseOrphanRecovery(t *testing.T) {

package/internal/agent/stream_timeline_test.go

@@ -704,43 +704,8 @@ echo '{"type":"result","subtype":"success","is_error":false,"result":"<think>思
 	}
 }
 
-// TestTraeStreamStillDeltaOnly trae 协议没有 message 概念，
-// 但降级 id 仍要**本轮内稳定**（否则一条消息被拆成多段）。
-func TestTraeStreamStillDeltaOnly(t *testing.T) {
-	skipIfNoShCLI(t)
-	cli := writeFakeCLI(t, "trae-cli", `#!/bin/sh
-echo '{"type":"stream_event","delta":{"role":"assistant","content":"你"}}'
-echo '{"type":"stream_event","delta":{"role":"assistant","content":"好"}}'
-echo '{"type":"result","subtype":"success","is_error":false,"result":"你好"}'
-`)
-	e := &TraeEngine{BinPath: cli}
-	events, onEvent := collectEvents()
-	if _, err := e.Stream(context.Background(), Request{
-		Messages: []Message{{Role: "user", Content: "hi"}},
-	}, onEvent); err != nil {
-		t.Fatalf("Stream: %v", err)
-	}
-	var id string
-	var lastSnap string
-	for _, ev := range *events {
-		if ev.Kind != KindText {
-			continue
-		}
-		if ev.ItemID == "" {
-			t.Fatal("trae 的正文也应有 item id（降级序号）")
-		}
-		if id == "" {
-			id = ev.ItemID
-		}
-		if ev.ItemID != id {
-			t.Fatalf("trae 降级 id 不稳定：%q vs %q", id, ev.ItemID)
-		}
-		lastSnap = ev.Snapshot
-	}
-	if lastSnap != "你好" {
-		t.Errorf("最终 snapshot = %q，want 你好", lastSnap)
-	}
-}
+// trae 2.0 走 trae_exec.go 的独立累加器（不使用 streamAccumulator），
+// 其事件映射由 stream_test.go 的 TestTraeStreamExecJSON 覆盖。
 
 // ── arkclaw 专项（A2A message/stream）─────────────────────────────────
 //