magic-agent 2.4.3 → 2.6.3

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）──
 	 *
@@ -249,6 +258,25 @@ type StreamEvent struct {
 	//（同走 agent.ReasonOf），同一次失败在事件流与 stderr 两处的说法必然一致。
 	Reason string
 
+	/* ── 失败分类（2026-10-25）──
+	 *
+	 * 为什么要有这三个字段：客户端要画一张**额度卡**（什么时候恢复、该怎么办），
+	 * 而 Error / Reason 只有一段人话原文。让每个客户端各自从原文里正则反推，
+	 * 就是三端三套判据、各错各的；分类口径收在 core（见 limitnotice.go），
+	 * 客户端只做展示。
+	 *
+	 * 空串 = 与以前完全一致（非 turn_failed 的事件、以及认不出类别的失败）。
+	 * 按 CLIENT-CONTRACT 的「只增字段不升 contractVersion」规则添加，
+	 * 老消费方忽略它们即可。 */
+
+	// ErrorKind 失败类别：quota（额度用尽）/ rate_limit（频率限制）/ ""（未分类）。
+	ErrorKind string
+	// ErrorCode 通告里的状态码（429 / 402 / 401 / 403 / 5xx），空 = 原文里没有。
+	ErrorCode string
+	// ResetAt 供应商给的恢复时刻（RFC3339）。空 = 通告里没说什么时候恢复 ——
+	// 客户端此时**不要**编「稍后」，把这一行整条省掉。
+	ResetAt string
+
 	/* Parent 父委派 id（2026-10-21，团队模式）。
 	 *
 	 * 语义与 claude 系原生的 `parent_tool_use_id` 完全一致：非空表示「这条事件发生在
@@ -312,7 +340,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 +555,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 +786,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 +975,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 +1018,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 +1471,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 +1696,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)
 	}
@@ -1599,6 +1748,10 @@ func (a *streamAccumulator) emitTurnFailed(sessionID string, err error) {
 		Reason:    ReasonOf(err),
 		Status:    StatusFailed,
 	}
+	/* 「协议没跑完」的错误串里也可能夹着供应商的 429 原文（runner 的重试判据就是
+	   靠这种子串认出来的），所以这里同样分一次类 —— 认出来客户端才画得出额度卡。 */
+	ev.ErrorKind, ev.ErrorCode = classifyNotice(ev.Reason + "\n" + ev.Error)
+	ev.ResetAt = noticeResetRFC3339(ev.Reason + "\n" + ev.Error)
 	// 已建立 item 时把失败也挂到同一个 item 上：partial 的内容仍然存在，
 	// 只是这条 item 不会再更新了（Status=failed 明确终止增长）。
 	if attrs, ok := a.trackers().failText(a.joinBlocks(a.textBlocks)); ok {
@@ -1632,6 +1785,13 @@ func (a *streamAccumulator) emitLimitNoticeFailed(sessionID, notice, body string
 		Reason:    notice,
 		Status:    StatusFailed,
 	}
+	/* 分类与恢复时刻就在这里定（客户端只展示，不自己解析原文）——
+	   这条路径**已经认定**是限流/额度通告，所以 kind 至少是 rate_limit。 */
+	ev.ErrorKind, ev.ErrorCode = classifyNotice(notice)
+	if ev.ErrorKind == "" {
+		ev.ErrorKind = ErrorKindRateLimit
+	}
+	ev.ResetAt = noticeResetRFC3339(notice)
 	/* 快照 = 剥掉通告的正文；正文为空（这一轮引擎只回了通告）时退回**累积正文** ——
 	   引擎把通告混在最后一条 assistant 消息里时，那里面也夹着它，再判一次剥掉。
 	   （累积正文里判不出来就原样留着：宁可多留一句话，也不把用户真看过的正文抹成空。） */

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）─────────────────────────────────
 //

package/internal/agent/streamjson.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"sync"
 )
 
 // streamJSONResult 两家 CLI 收尾行（type=result）的公共形状。
@@ -64,7 +65,17 @@ func runStreamJSONIn(
 			   ⚠️ 抛错会让 lineHandler 中止读循环，那里会顺手 kill 掉引擎进程组
 			   （见 runStreamCLIStdinReaderIn），所以这里不能改成「先把事件转发出去、
 			   等收尾再抛」—— 那样 turn_failed 会晚到，消费方早就按 turn_end 收尾了。 */
-			if notice, body, hit := splitLimitNotice(fin.Result); hit {
+			/* ⚠️ **判的是「屏幕上真正显示的那段」，不是 result 字段**（2026-10-25）：
+			   AggregateOnly 引擎（codebuddy 实测）不发 content_block_delta，正文只随
+			   assistant 聚合行以 text 增量下来，而收尾 result 行的 result **是空串** ——
+			   只判 fin.Result 的话，额度通告永远认不出来，界面上就是「一整段 429 英文 +
+			   已完成」（用户 2026-10-25 截图报障：「没额度了」）。
+			   口径与 emitTurnEnd 的落笔一致：result 非空以它为准，空则退回累积正文。 */
+			shown := fin.Result
+			if strings.TrimSpace(shown) == "" {
+				shown = acc.joinBlocks(acc.textBlocks)
+			}
+			if notice, body, hit := splitLimitNotice(shown); hit {
 				acc.emitLimitNoticeFailed(fin.SessionID, notice, body)
 				return errors.New(notice)
 			}
@@ -81,9 +92,13 @@ func runStreamJSONIn(
 // streamJSONInputPipe 常驻会话的 stdin：先写首条 user 消息（提示词 + 附件），
 // 之后每从 appendCh 收到一条就再写一轮；appendCh 关闭 → 关掉写端 → 子进程收尾。
 //
+// replyCh 非 nil 时同时接收**原生控制应答行**（control_response，见 Request.Reply）：
+// 它和 appendCh 是两条独立的通道 —— 追加是「下一轮用户消息」，应答是「这一轮正等着的裁决」，
+// 混在一条通道里会让 CLI 把应答当 user 消息读（实测后果：整轮卡死）。
+//
 // 返回的 reader 交给子进程当 stdin（不 EOF 就一直活着）。写失败（子进程已退）时
 // 直接收摊，不让 goroutine 泄漏。
-func streamJSONInputPipe(prompt string, atts []Attachment, appendCh <-chan string) (io.Reader, error) {
+func streamJSONInputPipe(prompt string, atts []Attachment, appendCh <-chan string, replyCh <-chan string) (io.Reader, error) {
 	first, err := streamJSONUserLine(prompt, atts)
 	if err != nil {
 		return nil, err
@@ -94,19 +109,116 @@ func streamJSONInputPipe(prompt string, atts []Attachment, appendCh <-chan strin
 		if _, err := pw.Write([]byte(first)); err != nil {
 			return
 		}
-		for msg := range appendCh {
-			line, lerr := streamJSONUserLine(msg, nil)
-			if lerr != nil {
-				continue // 追加内容构造失败（不该发生）：跳过这一条，别把整个会话带崩
+		for {
+			select {
+			case msg, ok := <-appendCh:
+				if !ok {
+					return // 追加入口关闭 = 收工
+				}
+				line, lerr := streamJSONUserLine(msg, nil)
+				if lerr != nil {
+					continue // 追加内容构造失败（不该发生）：跳过这一条，别把整个会话带崩
+				}
+				if _, err := pw.Write([]byte(line)); err != nil {
+					return
+				}
+			case raw, ok := <-replyCh:
+				if !ok {
+					replyCh = nil // 应答通道关闭不等于收工：继续等 append
+					continue
+				}
+				if _, err := pw.Write(ensureTrailingNewline(raw)); err != nil {
+					return
+				}
 			}
-			if _, err := pw.Write([]byte(line)); err != nil {
+		}
+	}()
+	return pr, nil
+}
+
+// streamJSONLiveInput 一轮式调用的「活 stdin」：写完首条 user 消息后**保持写端打开**，
+// 只用来把原生控制应答行（control_response）喂回去；done 关闭即 EOF。
+//
+// 为什么不能继续用 strings.Reader（2026-10-25 实测）：那个 reader 一读完就 EOF，
+// CLI 随后发出 control_request（计划审批）时 stdin 已经关掉 —— 应答没有落点，
+// 整轮只能挂到超时。而只要把 stdin 留着，CLI 在被批准后就会继续跑完这一轮。
+// ⚠️ 代价：stdin 一直开着时 CLI 在吐完 result 后**不会自己退出**（实测），
+// 所以调用方必须在收到 turn_end / result / error 时立刻关掉 done —— 不能等 Stream 返回。
+func streamJSONLiveInput(prompt string, atts []Attachment, replyCh <-chan string, done <-chan struct{}) (io.Reader, error) {
+	first, err := streamJSONUserLine(prompt, atts)
+	if err != nil {
+		return nil, err
+	}
+	pr, pw := io.Pipe()
+	go func() {
+		defer pw.Close()
+		if _, err := pw.Write([]byte(first)); err != nil {
+			return
+		}
+		for {
+			select {
+			case <-done:
 				return
+			case raw, ok := <-replyCh:
+				if !ok {
+					replyCh = nil
+					continue
+				}
+				if _, err := pw.Write(ensureTrailingNewline(raw)); err != nil {
+					return
+				}
 			}
 		}
 	}()
 	return pr, nil
 }
 
+// streamJSONStdinFor 按 Request 的通道形态挑 stdin 实现（claude / codebuddy 共用）。
+//
+//	Append 非 nil  → 常驻会话（续轮）流；Reply 一并接上
+//	Reply  非 nil  → 一轮式「活 stdin」：只为准许回 control_response 而保持打开
+//	都没有          → 老行为：一行写完即 EOF
+//
+// 返回的 close 由调用方 defer —— 活 stdin 下它负责 EOF，让 CLI 退出。
+func streamJSONStdinFor(req Request, prompt string) (io.Reader, func(), error) {
+	if req.Append != nil {
+		pipe, err := streamJSONInputPipe(prompt, req.Attachments, req.Append, req.Reply)
+		return pipe, func() {}, err
+	}
+	if req.Reply != nil {
+		done := make(chan struct{})
+		var once sync.Once
+		closeFn := func() { once.Do(func() { close(done) }) }
+		pipe, err := streamJSONLiveInput(prompt, req.Attachments, req.Reply, done)
+		if err != nil {
+			return nil, func() {}, err
+		}
+		return pipe, closeFn, nil
+	}
+	line, err := streamJSONUserLine(prompt, req.Attachments)
+	if err != nil {
+		return nil, func() {}, err
+	}
+	return strings.NewReader(line), func() {}, nil
+}
+
+// streamTerminalKind 这一条事件是否代表「本轮结束」（活 stdin 据此立刻 EOF）。
+func streamTerminalKind(k StreamEventKind) bool {
+	switch k {
+	case KindTurnEnd, KindTurnFailed:
+		return true
+	}
+	return false
+}
+
+// ensureTrailingNewline 保证写进 stdin 的每一行都以换行结尾（NDJSON 一行一条）。
+func ensureTrailingNewline(s string) []byte {
+	if strings.HasSuffix(s, "\n") {
+		return []byte(s)
+	}
+	return []byte(s + "\n")
+}
+
 // streamJSONUserLine 把「提示词 + 附件」拼成一行 stream-json 输入（含结尾换行）。
 //
 // content 块顺序：图片附件（image block）在前、提示词文本在后 —— 与官方

package/internal/agent/tools_suffix_test.go

@@ -24,7 +24,10 @@ func argLogger(t *testing.T) (string, func() string) {
 	log := filepath.Join(dir, "args.log")
 	cli := filepath.Join(dir, "fake")
 	script := "#!/bin/sh\nprintf '%s\\n' \"$*\" > " + log +
-		"\necho '{\"type\":\"result\",\"result\":\"ok\"}'\n"
+		"\necho '{\"type\":\"result\",\"result\":\"ok\"}'\n" +
+		// trae 2.0 的 JSONL 事件（同一个假 CLI 要同时被 claude/codebuddy/trae 复用）
+		"\necho '{\"type\":\"item.completed\",\"item\":{\"id\":\"i\",\"type\":\"agent_message\",\"text\":\"ok\"}}'\n" +
+		"\necho '{\"type\":\"turn.completed\"}'\n"
 	if err := os.WriteFile(cli, []byte(script), 0o755); err != nil {
 		t.Fatal(err)
 	}
@@ -131,9 +134,9 @@ func TestTraeToolModeSuffix(t *testing.T) {
 	}
 }
 
-// TestTraeToolModeMapping 固化 trae 的工具模式契约（2026-09-16 真机验证）。
+// TestTraeToolModeMapping 固化 trae 的工具模式契约（2026-09-16 真机验证，2.0 同构）。
 //
-// trae-cli 的权限开关实测语义：
+// TRAE CLI 的权限开关语义：
 //   - --allowed-tool 只做「自动批准」，不裁剪工具集（--allowed-tool WebFetch
 //     仍下发全部 18 个工具）；
 //   - --disallowed-tool 才真正做减法；