magic-agent 1.0.3 → 1.0.49

package/internal/agent/codebuddy_gateway_test.go

@@ -242,14 +242,34 @@ func TestCodeBuddyGatewayCompletedEmitsRemainderOnly(t *testing.T) {
 	srv, _ := cbGatewayTestServer(t, "run-1", frames)
 	e := cbGatewayServerEngine(srv)
 
+	// ⚠️ 必须**按 kind 过滤**收集，不能无脑 append ev.Text：
+	// Text 字段在多种事件上都有值（turn_end 带权威全文、tool_use 带 args JSON），
+	// 无脑收集在 claude 上本来就会把工具参数混进「正文」。这里顺带把
+	// 「正文只来自 KindText」这条不变量也钉住。
 	var got []string
+	var end *StreamEvent
 	if _, err := e.Stream(context.Background(), Request{Messages: []Message{{Role: "user", Content: "x"}}},
-		func(ev StreamEvent) { got = append(got, ev.Text) }); err != nil {
+		func(ev StreamEvent) {
+			switch ev.Kind {
+			case KindText:
+				got = append(got, ev.Text)
+			case KindTurnEnd:
+				ev := ev
+				end = &ev
+			}
+		}); err != nil {
 		t.Fatalf("Stream 失败: %v", err)
 	}
 	if len(got) != 2 || got[0] != "你好" || got[1] != "，世界" {
 		t.Errorf("增量 = %v want [你好 ，世界]", got)
 	}
+	// 轮次边界：turn_end 带权威全文（与 claude / dsh 同一约定，见 finish 的注释）。
+	if end == nil {
+		t.Fatal("缺少 turn_end 轮次边界事件")
+	}
+	if end.Text != "你好，世界" {
+		t.Errorf("turn_end.Text = %q，want 权威全文「你好，世界」", end.Text)
+	}
 }
 
 func TestCodeBuddyGatewayErrorFrame(t *testing.T) {
@@ -671,3 +691,218 @@ func TestCodeBuddyGatewayStreamTimeout(t *testing.T) {
 		t.Errorf("超时没生效，耗时 %v", time.Since(start))
 	}
 }
+
+// ---------- 状态收敛（2026-10-02）----------
+
+// TestCodeBuddyGatewayConverges 整条流必须给出「同 item id、单调 revision、
+// running…→ final」的完整收敛序列。
+//
+// 这条挡的是「接了 tracker 但没接进 emit 路径」这类接线错误 ——
+// 单元测试全绿但 wire 上没有 item_id，症状是消费方拿不到收敛能力。
+func TestCodeBuddyGatewayConverges(t *testing.T) {
+	frames := []string{
+		cbGatewayFrameJSON("streaming", `"content":{"chunk":"第一"}`),
+		cbGatewayFrameJSON("streaming", `"content":{"chunk":"第二"}`),
+		cbGatewayFrameJSON("completed", `"content":{"markdown":"第一第二"}`),
+	}
+	srv, _ := cbGatewayTestServer(t, "run-conv-1", frames)
+	e := cbGatewayServerEngine(srv)
+
+	var evs []StreamEvent
+	if _, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "x"}},
+	}, func(ev StreamEvent) { evs = append(evs, ev) }); err != nil {
+		t.Fatalf("Stream 失败: %v", err)
+	}
+
+	var texts []StreamEvent
+	var ends []StreamEvent
+	for _, ev := range evs {
+		switch ev.Kind {
+		case KindText:
+			texts = append(texts, ev)
+		case KindTurnEnd:
+			ends = append(ends, ev)
+		}
+	}
+	// 两帧 streaming 各一条正文；completed 帧正文与已发增量相同（前缀去重后差量为空），
+	// 所以正文只有 2 条，轮次边界由 turn_end 承担。
+	if len(texts) != 2 {
+		t.Fatalf("text 事件数 = %d，want 2：%+v", len(texts), texts)
+	}
+	if len(ends) != 1 {
+		t.Fatalf("turn_end 事件数 = %d，want 1：%+v", len(ends), ends)
+	}
+	// turn_end 承担 final：同 item id + 更高 revision。
+	if ends[0].ItemID != texts[0].ItemID {
+		t.Errorf("turn_end 应挂在正文 item 上：%q vs %q", ends[0].ItemID, texts[0].ItemID)
+	}
+	if ends[0].ItemRevision <= texts[len(texts)-1].ItemRevision {
+		t.Errorf("turn_end revision 必须更高：正文末帧=%d turn_end=%d",
+			texts[len(texts)-1].ItemRevision, ends[0].ItemRevision)
+	}
+	if ends[0].Status != StatusFinal {
+		t.Errorf("turn_end status = %q，want final", ends[0].Status)
+	}
+	for i, ev := range texts {
+		if ev.ItemID == "" || ev.ItemRevision == 0 {
+			t.Errorf("[%d] 缺收敛字段: %+v", i, ev)
+		}
+		if !strings.HasPrefix(ev.ItemID, "codebuddy-gateway_msg_") {
+			t.Errorf("[%d] item id 前缀不对: %q", i, ev.ItemID)
+		}
+	}
+	// 同一条 item（整轮只有一个 run）→ id 全同。
+	for i, ev := range texts {
+		if ev.ItemID != texts[0].ItemID {
+			t.Errorf("[%d] item id 变了：%q vs %q", i, ev.ItemID, texts[0].ItemID)
+		}
+	}
+	// revision 严格递增，末帧为 final。
+	for i := 1; i < len(texts); i++ {
+		if texts[i].ItemRevision <= texts[i-1].ItemRevision {
+			t.Errorf("revision 未递增：%d 之后是 %d", texts[i-1].ItemRevision, texts[i].ItemRevision)
+		}
+	}
+	if texts[0].Status != StatusRunning {
+		t.Errorf("首帧 status = %q，want running", texts[0].Status)
+	}
+}
+
+// TestCodeBuddyGatewaySnapshotIsCumulative snapshot 必须是**累积整段**，
+// text 才是增量 —— 两者混了就等于没有收敛能力。
+//
+// 特别验 completed 帧那一帧：传入 emitText 的是「差量」（此处为空所以不发），
+// 但 snapshot 仍要等于累积到此刻的全文，不能是差量或空串。
+func TestCodeBuddyGatewaySnapshotIsCumulative(t *testing.T) {
+	frames := []string{
+		cbGatewayFrameJSON("streaming", `"content":{"chunk":"你好"}`),
+		cbGatewayFrameJSON("streaming", `"content":{"chunk":"世界"}`),
+		cbGatewayFrameJSON("completed", `"content":{"markdown":"你好世界！"}`),
+	}
+	srv, _ := cbGatewayTestServer(t, "run-conv-2", frames)
+	e := cbGatewayServerEngine(srv)
+
+	var texts, ends []StreamEvent
+	if _, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "x"}},
+	}, func(ev StreamEvent) {
+		switch ev.Kind {
+		case KindText:
+			texts = append(texts, ev)
+		case KindTurnEnd:
+			ends = append(ends, ev)
+		}
+	}); err != nil {
+		t.Fatalf("Stream 失败: %v", err)
+	}
+	if len(texts) != 3 {
+		t.Fatalf("text 事件数 = %d，want 3：%+v", len(texts), texts)
+	}
+	if len(ends) != 1 {
+		t.Fatalf("turn_end 事件数 = %d，want 1：%+v", len(ends), ends)
+	}
+
+	// 逐帧校验：text 是增量，snapshot 是累积。
+	wantDelta := []string{"你好", "世界", "！"}
+	wantSnap := []string{"你好", "你好世界", "你好世界！"}
+	for i, ev := range texts {
+		if ev.Text != wantDelta[i] {
+			t.Errorf("[%d] text = %q，want 增量 %q", i, ev.Text, wantDelta[i])
+		}
+		if ev.Snapshot != wantSnap[i] {
+			t.Errorf("[%d] snapshot = %q，want 累积 %q", i, ev.Snapshot, wantSnap[i])
+		}
+	}
+	// 终帧（turn_end）的 snapshot 必须是完整正文。
+	if ends[0].Snapshot != "你好世界！" {
+		t.Errorf("turn_end snapshot = %q，want 全文", ends[0].Snapshot)
+	}
+	if ends[0].Text != "你好世界！" {
+		t.Errorf("turn_end text = %q，want 权威全文", ends[0].Text)
+	}
+}
+
+// TestCodeBuddyGatewayNoItemIDWithoutEvents onEvent 为 nil（非流式 Complete 路径）
+// 时不发任何事件，自然也不该构造 tracker。
+func TestCodeBuddyGatewayCompleteHasNoItemID(t *testing.T) {
+	frames := []string{cbGatewayFrameJSON("completed", `"content":{"markdown":"完成"}`)}
+	srv, _ := cbGatewayTestServer(t, "run-conv-3", frames)
+	e := cbGatewayServerEngine(srv)
+
+	res, err := e.Complete(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "x"}},
+	})
+	if err != nil {
+		t.Fatalf("Complete 失败: %v", err)
+	}
+	if res.Text != "完成" {
+		t.Errorf("Text = %q", res.Text)
+	}
+}
+
+// TestCodeBuddyGatewayTurnFailedOnTruncatedStream 流被截断（没有 completed 帧）
+// 必须补 turn_failed，否则那条 item 永远停在 running —— 消费方只能靠超时猜，
+// 历史回放里那一条会永远显示「生成中」。
+func TestCodeBuddyGatewayTurnFailedOnTruncatedStream(t *testing.T) {
+	frames := []string{
+		cbGatewayFrameJSON("streaming", `"content":{"chunk":"只说了半句"}`),
+	}
+	srv, _ := cbGatewayTestServer(t, "run-fail-1", frames)
+	e := cbGatewayServerEngine(srv)
+
+	var texts, failed []StreamEvent
+	_, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "x"}},
+	}, func(ev StreamEvent) {
+		switch ev.Kind {
+		case KindText:
+			texts = append(texts, ev)
+		case KindTurnFailed:
+			failed = append(failed, ev)
+		}
+	})
+	if err == nil {
+		t.Fatal("无终帧的流应报错")
+	}
+	if len(texts) != 1 || len(failed) != 1 {
+		t.Fatalf("事件形状 = text %d / turn_failed %d，want 1/1", len(texts), len(failed))
+	}
+	// failed 挂在同一个 item 上：partial 还在，只是这条 item 不再增长。
+	if failed[0].ItemID != texts[0].ItemID {
+		t.Errorf("turn_failed 应挂在正文 item 上：%q vs %q", failed[0].ItemID, texts[0].ItemID)
+	}
+	if failed[0].Status != StatusFailed {
+		t.Errorf("status = %q，want failed", failed[0].Status)
+	}
+	if failed[0].ItemRevision <= texts[0].ItemRevision {
+		t.Errorf("turn_failed revision 必须更高：%d vs %d", failed[0].ItemRevision, texts[0].ItemRevision)
+	}
+	if failed[0].Error == "" || failed[0].Reason == "" {
+		t.Errorf("turn_failed 必须带 error / reason：%+v", failed[0])
+	}
+	if failed[0].Snapshot != "只说了半句" {
+		t.Errorf("snapshot = %q，want 保留 partial", failed[0].Snapshot)
+	}
+}
+
+// TestCodeBuddyGatewayNoTurnFailedWithoutText 一句正文都没流出来时**不该**造
+// failed 帧：消费方会凭空多出一条空 item。
+func TestCodeBuddyGatewayNoTurnFailedWithoutText(t *testing.T) {
+	// 只有受理帧，没有 streaming / completed。
+	srv, _ := cbGatewayTestServer(t, "run-empty-1", []string{
+		cbGatewayFrameJSON("accepted", ""),
+	})
+	e := cbGatewayServerEngine(srv)
+
+	var kinds []StreamEventKind
+	_, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "x"}},
+	}, func(ev StreamEvent) { kinds = append(kinds, ev.Kind) })
+	if err == nil {
+		t.Fatal("无终帧的流应报错")
+	}
+	if len(kinds) != 0 {
+		t.Errorf("没有正文时不该发任何事件，收到 %v", kinds)
+	}
+}

package/internal/agent/codebuddy_stream_test.go

@@ -0,0 +1,262 @@
+package agent
+
+// codebuddy_stream_test.go - codebuddy 专属流式协议差异的回归测试（2026-10-01）。
+//
+// codebuddy 与 claude 同源但**协议有两处不同**，两处都只表现为
+// 「输出为空 / 输出里混进英文推理」，不报错、退出码 0：
+//
+//  1. 正文走 assistant 聚合行兜底（AggregateOnly）。协议形态变过两次：
+//     2026-10-01 只发聚合行、不发 delta（不开 AggregateOnly → `-o text`
+//     实时输出全程空白）；2026-10-11 新版 CLI 增量与聚合行**并存**
+//     （聚合行无条件重发全文 → snapshot 全文×2 → 移动端「消息显示重复」）。
+//     两条形态都有测试钉住。
+//  2. 思维链以 <think>…</think> 塞进正文 result 字符串。
+//     不剥 → 用户看到的回答前面挂着一段英文推理。
+//
+// 两个开关都是"多发/少发"级别的错，所以必须有断言钉住。
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestAggregateOnlyEmitsFromAssistantLine AggregateOnly 引擎的正文必须实时出来。
+func TestAggregateOnlyEmitsFromAssistantLine(t *testing.T) {
+	lines := []string{
+		`{"type":"system","subtype":"init","session_id":"cb-1","model":"hy3"}`,
+		`{"type":"assistant","session_id":"cb-1","message":{"role":"assistant","content":[{"type":"text","text":"你好"}]}}`,
+		`{"type":"result","subtype":"success","is_error":false,"result":"你好","session_id":"cb-1"}`,
+	}
+	acc := &streamAccumulator{Engine: "codebuddy", AggregateOnly: true}
+	evs := feedNDJSON(t, acc, lines)
+
+	var texts []string
+	for _, ev := range evs {
+		if ev.Kind == KindText {
+			texts = append(texts, ev.Text)
+		}
+	}
+	if len(texts) != 1 || texts[0] != "你好" {
+		t.Fatalf("正文事件 = %q，want 恰好一条「你好」", texts)
+	}
+	if acc.Text.String() != "你好" {
+		t.Fatalf("acc.Text = %q", acc.Text.String())
+	}
+}
+
+// TestAggregateOnlyOffDoesNotDuplicate 非 AggregateOnly 引擎（claude/trae）
+// 绝不能从聚合行再发一遍正文 —— 增量已经在 stream_event 里发过了。
+//
+// 这条是「AggregateOnly 必须由引擎显式声明、不能全局打开」的护栏。
+func TestAggregateOnlyOffDoesNotDuplicate(t *testing.T) {
+	lines := []string{
+		// 增量路径（claude 正常形态）
+		`{"type":"stream_event","event":{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"你好"}}}`,
+		// 同一轮的聚合行
+		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"你好"}]}}`,
+	}
+	acc := &streamAccumulator{Engine: "claude"} // AggregateOnly 缺省 false
+	evs := feedNDJSON(t, acc, lines)
+
+	n := 0
+	for _, ev := range evs {
+		if ev.Kind == KindText {
+			n++
+			if ev.Text != "你好" {
+				t.Fatalf("正文事件 = %q", ev.Text)
+			}
+		}
+	}
+	if n != 1 {
+		t.Fatalf("正文事件条数 = %d，want 1（开了就重复输出了）", n)
+	}
+	if acc.Text.String() != "你好" {
+		t.Fatalf("acc.Text = %q，want 只有一份", acc.Text.String())
+	}
+}
+
+// TestAggregateOnlyCoexistsWithDelta 回归（2026-10-11，移动端「消息显示重复」）：
+// 新版 codebuddy CLI 增量与聚合行**并存** —— stream_event 逐字发正文，
+// 流尾 assistant 聚合行再给一次整段全文。emitAggregateText 若无条件把
+// 全文当增量 emit，snapshot 会变成「全文×2」（增量桶 + 0 号聚合桶并存，
+// joinBlocks 拼接），移动端 upsert 后整条消息显示两遍。
+func TestAggregateOnlyCoexistsWithDelta(t *testing.T) {
+	lines := []string{
+		`{"type":"system","subtype":"init","session_id":"cb-2"}`,
+		`{"type":"stream_event","event":{"type":"content_block_start","index":0,"content_block":{"type":"text"}}}`,
+		`{"type":"stream_event","event":{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"你好"}}}`,
+		`{"type":"stream_event","event":{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"世界"}}}`,
+		`{"type":"stream_event","event":{"type":"content_block_stop","index":0}}`,
+		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"你好世界"}]}}`,
+		`{"type":"result","subtype":"success","is_error":false,"result":"你好世界","session_id":"cb-2"}`,
+	}
+	acc := &streamAccumulator{Engine: "codebuddy", AggregateOnly: true}
+	evs := feedNDJSON(t, acc, lines)
+
+	var joined, lastSnap string
+	for _, ev := range evs {
+		if ev.Kind != KindText {
+			continue
+		}
+		joined += ev.Text
+		lastSnap = ev.Snapshot
+		if strings.Contains(ev.Snapshot, "你好世界你好世界") {
+			t.Fatalf("snapshot 重复累加了全文：%q", ev.Snapshot)
+		}
+	}
+	if lastSnap != "你好世界" {
+		t.Fatalf("最终 snapshot = %q，want 恰好一份「你好世界」", lastSnap)
+	}
+	if joined != "你好世界" {
+		t.Fatalf("text 事件流 = %q，want 拼起来恰好一份", joined)
+	}
+	if acc.Text.String() != "你好世界" {
+		t.Fatalf("acc.Text = %q，want 只有一份", acc.Text.String())
+	}
+}
+
+// TestAggregateOnlyEmitsOnlyDeltaTail 聚合行比已发增量多尾巴（增量被截断）
+// 时只补差量，不整段重发 —— 重发会让终端直打多一份全文。
+func TestAggregateOnlyEmitsOnlyDeltaTail(t *testing.T) {
+	lines := []string{
+		`{"type":"stream_event","event":{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"你好"}}}`,
+		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"你好世界"}]}}`,
+	}
+	acc := &streamAccumulator{Engine: "codebuddy", AggregateOnly: true}
+	evs := feedNDJSON(t, acc, lines)
+
+	var texts []string
+	for _, ev := range evs {
+		if ev.Kind == KindText {
+			texts = append(texts, ev.Text)
+		}
+	}
+	if len(texts) != 2 || texts[0] != "你好" || texts[1] != "世界" {
+		t.Fatalf("text 事件 = %q，want [你好 世界]（只补差量）", texts)
+	}
+	if acc.Text.String() != "你好世界" {
+		t.Fatalf("acc.Text = %q", acc.Text.String())
+	}
+}
+
+// TestAggregateOnlyStripsThinkFromLiveOutput 实时输出里不能出现思维链。
+func TestAggregateOnlyStripsThinkFromLiveOutput(t *testing.T) {
+	lines := []string{
+		`{"type":"assistant","message":{"role":"assistant","content":"<think>模型在推理英文</think>\n最终答案是 42"}}`,
+	}
+	acc := &streamAccumulator{Engine: "codebuddy", AggregateOnly: true}
+	evs := feedNDJSON(t, acc, lines)
+
+	var joined string
+	for _, ev := range evs {
+		if ev.Kind == KindText {
+			joined += ev.Text
+		}
+	}
+	if strings.Contains(joined, "<think>") || strings.Contains(joined, "模型在推理英文") {
+		t.Fatalf("实时输出里混进了思维链：%q", joined)
+	}
+	if !strings.Contains(joined, "最终答案是 42") {
+		t.Fatalf("正文丢了：%q", joined)
+	}
+}
+
+// TestAggregateOnlySkipsToolBlocks 聚合行里的工具块不能被当正文发出来。
+func TestAggregateOnlySkipsToolBlocks(t *testing.T) {
+	line := `{"type":"assistant","message":{"role":"assistant","content":[` +
+		`{"type":"thinking","thinking":"内部推理"},` +
+		`{"type":"tool_use","id":"tu_1","name":"Bash","input":{"command":"ls"}},` +
+		`{"type":"text","text":"命令已执行"}` +
+		`]}}`
+	acc := &streamAccumulator{Engine: "codebuddy", AggregateOnly: true}
+	evs := feedNDJSON(t, acc, []string{line})
+
+	var joined string
+	for _, ev := range evs {
+		if ev.Kind == KindText {
+			joined += ev.Text
+		}
+	}
+	if joined != "命令已执行" {
+		t.Fatalf("正文 = %q，want 只有「命令已执行」", joined)
+	}
+}
+
+// TestTurnEndSanitized 回归（2026-10-01 真实 E2E 抓到）：
+// `-o json` 的 NDJSON 里 text 干净、turn_end 却夹着 <think>…</think>。
+//
+// 根因：turn_end 的 Text 直接取 result 行的**原始** result 字段
+// （runStreamJSONIn 里 acc.emitTurnEnd(fin.Result, ...)），而同一轮的
+// text / result 都过了 stripThinkBlock。三个来源干净程度不一致。
+// 消费方把 turn_end 当轮次边界，推理就会被当成正文收进去。
+func TestTurnEndSanitized(t *testing.T) {
+	raw := `<think>The user asks… reasoning…</think>` + "\n\n最终答案"
+	acc := &streamAccumulator{Engine: "codebuddy", SanitizeTurnText: stripThinkBlock}
+	acc.OnEvent = func(ev StreamEvent) {
+		if ev.Kind != KindTurnEnd {
+			t.Fatalf("不该有别的 kind：%v", ev.Kind)
+		}
+		if strings.Contains(ev.Text, "<think>") || strings.Contains(ev.Text, "reasoning") {
+			t.Fatalf("turn_end 仍带思维链：%q", ev.Text)
+		}
+		if ev.Text != "最终答案" {
+			t.Fatalf("turn_end = %q，want「最终答案」", ev.Text)
+		}
+	}
+	acc.emitTurnEnd(raw, "s-1")
+}
+
+// TestTurnEndUntouchedWhenNoSanitizer 没声明清洗器的引擎（claude）必须原样透传。
+//
+// 挡的是「在 emitTurnEnd 里对所有引擎无脑套 think 剥离」：
+// 那样会切掉合法输出里恰好出现的 <think> 字面量。
+func TestTurnEndUntouchedWhenNoSanitizer(t *testing.T) {
+	const raw = "正常正文，含 <think> 字面量"
+	acc := &streamAccumulator{Engine: "claude"} // SanitizeTurnText 为 nil
+	got := ""
+	acc.OnEvent = func(ev StreamEvent) { got = ev.Text }
+	acc.emitTurnEnd(raw, "s-1")
+	if got != raw {
+		t.Fatalf("claude 的 turn_end 被改了：%q，want %q", got, raw)
+	}
+}
+
+// TestAssistantLineTextShapes assistantLineText 的两种 content 形态。
+func TestAssistantLineTextShapes(t *testing.T) {
+	if got := assistantLineText(`{"message":{"content":"纯字符串"}}`); got != "纯字符串" {
+		t.Errorf("字符串形态 = %q", got)
+	}
+	if got := assistantLineText(`{"message":{"content":[]}}`); got != "" {
+		t.Errorf("空数组 = %q", got)
+	}
+	if got := assistantLineText(`{}`); got != "" {
+		t.Errorf("无 content = %q", got)
+	}
+	if got := assistantLineText(`not json`); got != "" {
+		t.Errorf("非 JSON = %q", got)
+	}
+	// 多段 text 用换行连接（不用空格：正文里空格可能有语义）。
+	if got := assistantLineText(`{"message":{"content":[{"type":"text","text":"A"},{"type":"text","text":"B"}]}}`); got != "A\nB" {
+		t.Errorf("多段拼接 = %q，want A\\nB", got)
+	}
+}
+
+// TestStripThinkBlock 思维链剥离的边界行为。
+func TestStripThinkBlock(t *testing.T) {
+	cases := []struct{ name, in, want string }{
+		{"无标签原样", "普通正文", "普通正文"},
+		{"前置思维链被剥", "<think>abc</think>正文", "正文"},
+		{"多段只留最后一个之后", "<think>a</think>中<think>b</think>尾", "尾"},
+		{"只有思维链返回空", "<think>只有推理</think>", ""},
+		{"未闭合不动", "<think>没闭合", "<think>没闭合"},
+		{"空串", "", ""},
+		{"闭标签无开标签", "</think>孤立", "</think>孤立"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := stripThinkBlock(c.in); got != c.want {
+				t.Errorf("stripThinkBlock(%q) = %q，want %q", c.in, got, c.want)
+			}
+		})
+	}
+}

package/internal/agent/codex.go

@@ -83,8 +83,8 @@ type CodexEngine struct {
 // Name 实现 Engine。
 func (e *CodexEngine) Name() string { return "codex" }
 
-// DefaultCodexTimeout 单次尝试默认超时（codex 沙箱+网路，整体偏慢）。
-const DefaultCodexTimeout = 8 * time.Minute
+// DefaultCodexTimeout 单次尝试默认超时（codex 沙箱+网路，整体偏慢；2026-10-10 由 8 分钟统一上调到 1 小时）。
+const DefaultCodexTimeout = time.Hour
 
 // bin 探测 codex CLI 路径（委托 cliBase 统一探测链）。
 func (e *CodexEngine) bin() string {
@@ -319,7 +319,7 @@ func (e *CodexEngine) Stream(ctx context.Context, req Request, onEvent func(Stre
 		extraEnv = append(extraEnv, "CODEX_HOME="+codexHome)
 	}
 
-	acc := &codexStreamAcc{OnEvent: onEvent}
+	acc := &codexStreamAcc{OnEvent: onEvent, OnSessionID: req.OnSessionID}
 	if err := runStreamCLIEnvIn(ctx, req.Workspace, extraEnv, bin, args, acc.handleLine); err != nil {
 		return StreamResult{}, err
 	}
@@ -351,6 +351,13 @@ type codexStreamAcc struct {
 	Thinking  strings.Builder
 	SessionID string
 	Usage     codexTurnUsage
+	// OnSessionID 见 Request.OnSessionID：codex 在流**最开头**的 thread.started 就给了
+	// thread_id，这里当场上报（2026-10-18——此前 codex 全程不调，是唯一漏掉的一脉）。
+	//
+	// 不报的后果不是「少一个回调」：日志 writer 拿不到 id 就永远按 `<run_id>.jsonl` 落盘，
+	// 而客户端手里的主键是 session_id —— 点开读到空历史（列表 has_log=true、详情「还没有事件」）。
+	// 别的一等引擎（claude / codebuddy / dsh / trae）都在这一层就报了，见各自 Stream 里的接线。
+	OnSessionID func(string)
 }
 
 func (a *codexStreamAcc) emit(ev StreamEvent) {
@@ -375,6 +382,9 @@ func (a *codexStreamAcc) handleLine(line string) error {
 		var ts codexThreadStarted
 		if json.Unmarshal([]byte(s), &ts) == nil && ts.ThreadID != "" {
 			a.SessionID = ts.ThreadID
+			if a.OnSessionID != nil {
+				a.OnSessionID(ts.ThreadID)
+			}
 		}
 	case "item.started", "item.completed":
 		a.handleItem(s, head.Type)
@@ -503,20 +513,36 @@ func (e *CodexEngine) buildArgs(req Request, prompt, outFile, schemaFile string)
 	}
 	// 通用 flags(放在子命令之后,prompt 之前)
 	args = append(args, "--skip-git-repo-check", "--json")
+	/* 续接轮（`exec resume`）只认一小组覆写参数 —— 0.162.0 的 `--help` 实测：
+	   `-c / --last / --all / --skip-git-repo-check / --json / -o / --output-schema /
+	   --ephemeral` 等，**没有 `-C`、也没有 `-m`**。传了 clap 直接
+	   `error: unexpected argument '-C' found` + exit 2、stdout 全空 → core 侧只能报
+	   「codex CLI returned empty result · 总耗时 0.0s」(2026-10-18 用户手机上那条
+	   「继续」就是这么死的）。所以下面这几项一律按子命令分流。 */
+	resuming := req.SessionID != "" || req.Continue
 	// 工作目录（workspace）：codex 有原生 `-C/--cd`（working root），优先用它 ——
 	// 它同时决定 sandbox 的可写根与相对路径解析；子进程 cwd 也一并设置（见调用点）。
-	if ws := strings.TrimSpace(req.Workspace); ws != "" {
+	// ⚠️ 续接轮没有 `-C` 可用，只能靠子进程 cwd（调用点已设），sandbox 根延用首次会话。
+	if ws := strings.TrimSpace(req.Workspace); ws != "" && !resuming {
 		args = append(args, "-C", ws)
 	}
 	// 注意:不能加 --ephemeral。codex 0.133 在 --ephemeral 模式下不会把
 	// session rollout 落盘,后续 --session 续接时报 "no rollout found for
 	// thread id"(实测 2026-09-16)。为保持与 claude 一致的"默认新会话可续接"策略,
 	// 始终不传 --ephemeral。
-	// 模型
-	if m := stripModelPrefix(req.Model); m != "" {
-		args = append(args, "-m", m)
-	} else if e.Model != "" {
-		args = append(args, "-m", stripModelPrefix(e.Model))
+	// 模型：`-m` 同样只属于 `codex exec`；续接轮改用配置覆写 `-c model="<m>"`
+	// （codex 帮助里就是拿 model 当 `-c` 的例子）。
+	if m := codexModelFor(req, e); m != "" {
+		if resuming {
+			args = append(args, "-c", "model="+tomlBasicString(m))
+		} else {
+			args = append(args, "-m", m)
+		}
+	}
+	// 推理档位：`-c` 在 `exec` 与 `exec resume` 下都可用（同 model 覆写），
+	// 故不按子命令分流。codex 的取值：minimal/low/medium/high/xhigh/max。
+	if lv := ReasoningLevel(req.Reasoning); lv != "" {
+		args = append(args, "-c", "model_reasoning_effort="+tomlBasicString(lv))
 	}
 	// SystemPrompt → -c developer_instructions=<TOML 字符串>
 	if req.SystemPrompt != "" {
@@ -566,6 +592,21 @@ func (e *CodexEngine) buildArgs(req Request, prompt, outFile, schemaFile string)
 	return args
 }
 
+// codexModelFor 定这一轮用哪个模型：请求显式指定优先，其次引擎配置（都去掉 `codex/` 前缀）。
+//
+// 为什么不复用 reqModelForCodex：那个的优先级是「引擎配置优先」（给收尾的 Response.Model 用），
+// 与这里**请求优先**的语义相反，混用会让 `-p --model X` 在 buildArgs 里失效。
+// 抽成函数只为一件事：调用点要按子命令决定用 `-m` 还是 `-c model=`（见 buildArgs）。
+func codexModelFor(req Request, e *CodexEngine) string {
+	if m := stripModelPrefix(req.Model); m != "" {
+		return m
+	}
+	if e.Model != "" {
+		return stripModelPrefix(e.Model)
+	}
+	return ""
+}
+
 // codexWebSearchOverride 读 MAGIC_AGENT_CODEX_WEBSEARCH 覆写值。
 // 仅接受 0.154 实测合法值域（disabled/cached/indexed/live），其余忽略。
 func codexWebSearchOverride() string {

package/internal/agent/codex_stream_test.go

@@ -95,3 +95,33 @@ func TestCodexImplementsStreamer(t *testing.T) {
 		t.Error("CodexEngine 应实现 Streamer（2026-09-17 补齐）")
 	}
 }
+
+// codex 必须在流**最开头**就把 thread_id 报给 OnSessionID（2026-10-18）。
+//
+// 日志 writer 靠这个回调把文件名从 `<run_id>.jsonl` 定成 `<session_id>.jsonl`；不报的话
+// 登记表里有 session_id、文件却永远叫 run_id，客户端按 session_id 点开读到空历史
+// （用户：「今天发的就不显示会话」）。claude / codebuddy / dsh / trae 都在这一层报了，
+// codex 此前是唯一漏掉的一脉。
+func TestCodexStreamReportsSessionID(t *testing.T) {
+	dir := t.TempDir()
+	bin := codexStreamStub(t, dir, []string{
+		`{"type":"thread.started","thread_id":"th-123"}`,
+		`{"type":"item.completed","item":{"type":"agent_message","text":"好"}}`,
+	})
+
+	var ids []string
+	_, err := (&CodexEngine{BinPath: bin}).Stream(context.Background(),
+		Request{
+			Tools:    ToolsOn,
+			Messages: []Message{{Role: "user", Content: "hi"}},
+			OnSessionID: func(id string) {
+				ids = append(ids, id)
+			},
+		}, nil)
+	if err != nil {
+		t.Fatalf("Stream: %v", err)
+	}
+	if len(ids) != 1 || ids[0] != "th-123" {
+		t.Fatalf("应上报一次 thread_id（th-123），实得 %v", ids)
+	}
+}