magic-agent 2.4.3 → 2.6.3

package/internal/agent/limitnotice_test.go

@@ -19,6 +19,7 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 )
 
 const (
@@ -30,6 +31,18 @@ const (
 	limitNoticeZH = "429 您的使用量已超出频率限制，将在 2026-09-19 17:49:56 UTC+8 重置，" +
 		"您也可以切换其他模型继续使用。"
 	limitNoticeNarration = "Let me read the file's end."
+	/* 实测英文额度通告（2026-10-25 用户报障截图里的那一轮原文，会话日志 01a16fea：
+	 **整段只有它**、前面没有正文、带两个尾巴）。与上面那条 429 的差别是措辞：
+	 这条说的是「5 小时额度用尽」，上面那条是「频率限制」。 */
+	limitNoticeQuotaEN = "429 You have exceeded the 5-hour usage quota. It will reset at " +
+		"2026-10-25 15:07:27 +0800 CST. We recommend upgrading your plan for more quota, " +
+		"or waiting for the reset. Request id: 021792911321900fd0de7354b348b065f00b895e07126b865f18b" +
+		" (01a171d5e11f7519bcf4077dffd2ebad/01a16fea-4a01-789d-b694-3d99c11b3c8b)"
+	/* 实测 402 原文（同一批日志里连出七条）：**没有恢复时刻**，却整段就是通告。
+	   它落在画面上就是「一大段供应商原文 + 已完成」—— 上面那条「有恢复时刻」的判据
+	   因此认不出它（2026-10-25 补的窄路就是为它）。 */
+	limitNoticeQuota402 = "402 当前已达到 Token Plan 用量上限。为避免调用中断，请升级 Token Plan 套餐，" +
+		"或购买积分补充用量并开启积分自动消耗。 (2067) (01a16c13a2e67c05b09eb8b1311f97d8/01a16c05-cabd-7fd0-9fdc-abca97cb92ae)"
 )
 
 func TestSplitLimitNoticeRealSamples(t *testing.T) {
@@ -81,6 +94,43 @@ func TestSplitLimitNoticeRealSamples(t *testing.T) {
 	}
 }
 
+// 2026-10-25 加的两条实测原文：英文 5 小时额度、中文 402（都没在前面挂正文）。
+func TestSplitLimitNoticeQuotaSamples(t *testing.T) {
+	notice, body, ok := splitLimitNotice(limitNoticeQuotaEN)
+	if !ok {
+		t.Fatalf("英文额度通告（截图里的那一轮）没认出来 —— 它会原样铺在气泡里")
+	}
+	if !strings.HasPrefix(notice, "429 You have exceeded") {
+		t.Errorf("notice = %q", notice)
+	}
+	if strings.Contains(notice, "01a171d5") || strings.Contains(notice, "Request id:") {
+		t.Errorf("notice = %q，尾巴应被剥掉（它会直接进卡片的原文行）", notice)
+	}
+	if body != "" {
+		t.Errorf("body = %q，want 空串（这一轮只回了通告）", body)
+	}
+
+	// 402 没有恢复时刻 → 走「整段就是通告」那条窄路。
+	notice, body, ok = splitLimitNotice(limitNoticeQuota402)
+	if !ok {
+		t.Fatalf("中文 402 原文没认出来（没有恢复时刻，靠窄路认）")
+	}
+	if !strings.HasPrefix(notice, "402 当前已达到") {
+		t.Errorf("notice = %q", notice)
+	}
+	if strings.Contains(notice, "2067") && !strings.Contains(notice, "积分") {
+		t.Errorf("notice = %q，尾巴 (2067) 应被剥掉", notice)
+	}
+	if body != "" {
+		t.Errorf("body = %q，want 空串", body)
+	}
+
+	// 402 前面挂着正文 → 不是「整段就是它」，不该整段吞掉（那条窄路只认 body 为空）。
+	if _, b, ok := splitLimitNotice("先跑了一遍测试。\n" + limitNoticeQuota402); ok && b != "先跑了一遍测试。" {
+		t.Errorf("正文被吞了：body = %q", b)
+	}
+}
+
 func TestSplitLimitNoticeNoFalsePositive(t *testing.T) {
 	cases := map[string]string{
 		"科普句（无限流措辞）":         "HTTP 429 是「请求过多」，服务端让你慢一点。",
@@ -89,6 +139,13 @@ func TestSplitLimitNoticeNoFalsePositive(t *testing.T) {
 		"正文里出现过 429、后面还有别的话": "日志里出现了 429。先看限流配置，额度在 2026-10-11 重置。建议改用另一个模型。",
 		"端口号不是状态码":           "端口 8080 与 usage 有关。",
 		"普通回答":               "已按你的要求改完 3 个文件。",
+		/* 窄路（整段就是通告、无时刻）要挡住的几类（2026-10-25）：
+		   「429 是限流，把额度用完就等它重置」= 模型在**回答**，措辞全中但没有一个字说
+		   「你此刻被拒了」。 */
+		"释义句（状态码在句首 + 表示）": "429 表示请求过多，额度用完时会自动重置，稍后再试即可。",
+		"释义句（中文「是」）":       "402 是「需要付费」的意思，余额不足时你先升级套餐。",
+		/* 长一点的正常回答里提了额度：整段不短于 160 字 → 不是那条窄路。 */
+		"长回答里提额度": strings.Repeat("这一版把额度用完时的提示改成了卡片。", 12),
 	}
 	for name, in := range cases {
 		if _, _, ok := splitLimitNotice(in); ok {
@@ -97,6 +154,89 @@ func TestSplitLimitNoticeNoFalsePositive(t *testing.T) {
 	}
 }
 
+// ── 分类与恢复时刻（2026-10-25，界面额度卡要的三项）────────────────────────
+
+func TestClassifyNotice(t *testing.T) {
+	cases := []struct{ in, kind, code string }{
+		{limitNoticeQuotaEN, ErrorKindQuota, "429"},
+		{limitNoticeQuota402, ErrorKindQuota, "402"},
+		{limitNoticeZH, ErrorKindRateLimit, "429"}, // 「超出频率限制」→ 短时窗口
+		{limitNoticeEN, ErrorKindRateLimit, "429"},
+		{"", "", ""},
+		{"codebuddy CLI stream ended without result line", "", ""},
+		/* 402 即使没有一句措辞也要算额度：它是「需要付费」的语义码（原文可能只有
+		   「Payment Required」），归到普通错误卡会让人去查配置。 */
+		{"402 Payment Required", ErrorKindQuota, "402"},
+	}
+	for _, c := range cases {
+		kind, code := classifyNotice(c.in)
+		if kind != c.kind || code != c.code {
+			t.Errorf("classifyNotice(%q) = (%q,%q)，want (%q,%q)", c.in, kind, code, c.kind, c.code)
+		}
+	}
+}
+
+func TestParseNoticeReset(t *testing.T) {
+	/* 三种拼法都是本仓库日志里的实测原文。**期望值是绝对时刻**，不看本机时区 ——
+	   带偏移的必须解成同一个瞬间（这就是不用宽松解析的理由：V8 会把 CST 当美国中部时间）。 */
+	cases := []struct{ in, want string }{
+		{limitNoticeQuotaEN, "2026-10-25T15:07:27+08:00"},                   // +0800 无冒号，尾部还有 CST
+		{limitNoticeZH, "2026-09-19T17:49:56+08:00"},                        // UTC+8 那种拼法
+		{limitNoticeEN, "2026-10-11T10:32:59+08:00"},                        // UTC+8
+		{"will reset at 2026-10-25T07:07:27Z", "2026-10-25T15:07:27+08:00"}, // ISO 形状（Z = UTC）
+		{limitNoticeQuota402, ""},                                           // 没有时刻 → 空（客户端不编「稍后」）
+		{"已按你的要求改完 3 个文件。", ""},
+	}
+	for _, c := range cases {
+		got := noticeResetRFC3339(c.in)
+		if c.want == "" {
+			if got != "" {
+				t.Errorf("noticeResetRFC3339(%q) = %q，want 空", c.in, got)
+			}
+			continue
+		}
+		wt, err := time.Parse(time.RFC3339, c.want)
+		if err != nil {
+			t.Fatalf("测试自身的期望值写错了：%v", err)
+		}
+		gt, err := time.Parse(time.RFC3339, got)
+		if err != nil {
+			t.Errorf("noticeResetRFC3339(%q) = %q（不是 RFC3339）", c.in, got)
+			continue
+		}
+		if !gt.Equal(wt) {
+			t.Errorf("noticeResetRFC3339(%q) = %s，want 同一瞬间 %s", c.in, got, c.want)
+		}
+	}
+}
+
+// 收尾事件要带上三项结构化字段（界面靠它们决定画额度卡还是普通失败卡）。
+func TestLimitNoticeEventCarriesFields(t *testing.T) {
+	var got *StreamEvent
+	a := &streamAccumulator{}
+	a.OnEvent = func(ev StreamEvent) { e := ev; got = &e }
+	a.emitLimitNoticeFailed("sid", strings.Join(strings.Fields(stripNoticeTails(limitNoticeQuotaEN)), " "), limitNoticeNarration)
+	if got == nil {
+		t.Fatal("没发事件")
+	}
+	if got.ErrorKind != ErrorKindQuota || got.ErrorCode != "429" {
+		t.Errorf("kind/code = %q/%q，want quota/429", got.ErrorKind, got.ErrorCode)
+	}
+	if got.ResetAt != "2026-10-25T15:07:27+08:00" {
+		t.Errorf("ResetAt = %q，want 2026-10-25T15:07:27+08:00", got.ResetAt)
+	}
+	if got.Text != limitNoticeNarration {
+		t.Errorf("Text = %q，want 剥掉通告的正文", got.Text)
+	}
+
+	// 402 那条：有 kind/code、**没有** reset（客户端据此不写「将于…恢复」）。
+	got = nil
+	a.emitLimitNoticeFailed("sid", strings.Join(strings.Fields(stripNoticeTails(limitNoticeQuota402)), " "), "")
+	if got == nil || got.ErrorKind != ErrorKindQuota || got.ErrorCode != "402" || got.ResetAt != "" {
+		t.Errorf("402 那条的 kind/code/reset = %+v", got)
+	}
+}
+
 // codebuddyStreamWithResult 造一个假 codebuddy CLI：只吐一条给定正文的 result 行。
 // 正文里带单引号（英文通告的 don't）时没法直接写进 shell 脚本，所以落成文件再 cat。
 func codebuddyStreamWithResult(t *testing.T, text string) string {

package/internal/agent/llmhttp.go

@@ -94,13 +94,55 @@ func buildConfiguredBody(m LLMConfigModel, req Request, stream bool) (map[string
 	}
 	if req.NoThinking && !LLMModelDisablesThinking(m) {
 		// 没有同线 no-think 变体时，用 llm/OpenAI 兼容端点认的官方参数。
-		// 若端点不支持该参数会返回 400 —— 这是显式 --disable-thinking 的预期失败，
-		// 不静默退回「假装关闭」。
+		// 个别模型不接受 `none`（如 MiniMax-M3.1-Flash 要求 adaptive thinking，
+		// 端点回 400 / 2013）—— 那不是「不能少思考」，只是这个档位不被允许：
+		// 由 doConfiguredRequestThinkingAware 换成它允许的最低档重试一次。
 		body["reasoning_effort"] = "none"
 	}
 	return body, nil
 }
 
+// noThinkingFallbackEffort 是「模型不接受完全关闭思考」时退而使用的最低档。
+//
+// 2026-10-24 用户纠正过一处误判：「invalid params ... requires adaptive thinking;
+// reasoning effort none is not allowed」**不代表模型不能少思考**，只是 `none` 这个
+// 档位不被允许。实测 MiniMax-M3.1-Flash：`none` → 400；`minimal` → 200；
+// `thinking.type=adaptive` → 200；`thinking.type=disabled` → 400。所以正确的做法是
+// 换档重试，而不是把用户选的模型换掉、也不是让整条链路失败。
+const noThinkingFallbackEffort = "minimal"
+
+// rejectsNoThinking 判断错误是不是「这个模型不接受关闭思考的写法」。
+// 认两条签名：`requires adaptive thinking` 与 `reasoning effort ... not allowed`；
+// 其它 4xx（鉴权、模型不存在、额度…）一律原样返回，不瞎重试。
+func rejectsNoThinking(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := strings.ToLower(err.Error())
+	if strings.Contains(msg, "requires adaptive thinking") {
+		return true
+	}
+	return strings.Contains(msg, "reasoning effort") && strings.Contains(msg, "not allowed")
+}
+
+// doConfiguredRequestThinkingAware 发一次请求；若模型拒绝 `reasoning_effort=none`，
+// 换成它允许的最低档（minimal）重试一次。
+//
+// 只在「我们主动塞了 none」时才换档：配置里显式声明的不思考变体
+// （extraBody.thinking.type=disabled）走的是另一条路，端点拒绝它是配置错误，
+// 换档只会把真正的原因盖住。
+func doConfiguredRequestThinkingAware(ctx context.Context, m LLMConfigModel, req Request, body map[string]any) (*http.Response, error) {
+	resp, err := doConfiguredRequest(ctx, m, req, body)
+	if err == nil || !rejectsNoThinking(err) {
+		return resp, err
+	}
+	if !req.NoThinking || LLMModelDisablesThinking(m) {
+		return nil, err
+	}
+	body["reasoning_effort"] = noThinkingFallbackEffort
+	return doConfiguredRequest(ctx, m, req, body)
+}
+
 // attachToLastUserMessage 把附件塞进最后一条 user 消息的 content：
 //
 //	图片  → {"type":"image_url","image_url":{"url":"data:<mime>;base64,<...>"}}（在前）
@@ -207,7 +249,7 @@ func (e *LLMEngine) completeConfigured(ctx context.Context, m LLMConfigModel, re
 	}
 	cctx, cancel := context.WithTimeout(ctx, llmConfiguredTimeout(m, req))
 	defer cancel()
-	resp, err := doConfiguredRequest(cctx, m, req, body)
+	resp, err := doConfiguredRequestThinkingAware(cctx, m, req, body)
 	if err != nil {
 		return Response{}, err
 	}
@@ -309,7 +351,7 @@ func (e *LLMEngine) streamConfigured(ctx context.Context, m LLMConfigModel, req
 	}
 	cctx, cancel := context.WithTimeout(ctx, llmConfiguredTimeout(m, req))
 	defer cancel()
-	resp, err := doConfiguredRequest(cctx, m, req, body)
+	resp, err := doConfiguredRequestThinkingAware(cctx, m, req, body)
 	if err != nil {
 		return StreamResult{}, err
 	}

package/internal/agent/llmhttp_test.go

@@ -20,6 +20,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
@@ -301,6 +302,162 @@ func TestBuildConfiguredBodyNoThinking(t *testing.T) {
 	}
 }
 
+// 2026-10-24 用户纠正的判定：「invalid params ... requires adaptive thinking;
+// reasoning effort none is not allowed」**不代表模型不能少思考**，只是 `none` 这个档位
+// 不被允许（实测 MiniMax-M3.1-Flash：none → 400，minimal / thinking.type=adaptive → 200）。
+// 所以应当**换档重试**，而不是把用户选的模型换掉、也不是让整条链路失败。
+func TestConfiguredNoThinkingFallsBackToAllowedEffort(t *testing.T) {
+	var mu sync.Mutex
+	var bodies []map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, _ := io.ReadAll(r.Body)
+		var b map[string]any
+		_ = json.Unmarshal(raw, &b)
+		mu.Lock()
+		bodies = append(bodies, b)
+		mu.Unlock()
+		if b["reasoning_effort"] == "none" {
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, `{"type":"error","error":{"type":"bad_request_error",`+
+				`"message":"invalid params, model \"MiniMax-M3.1-Flash\" requires adaptive thinking; `+
+				`reasoning effort none is not allowed (2013)","http_code":"400"}}`)
+			return
+		}
+		fmt.Fprint(w, `{"choices":[{"message":{"content":"处理过期 token","reasoning_content":"内部思路"}}]}`)
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{
+		{"id": "MiniMax-M3.1-Flash", "url": srv.URL + "/v1", "apiKey": "k"},
+	})
+
+	resp, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Complete(context.Background(), Request{
+		Engine: "llm", Model: "MiniMax-M3.1-Flash", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	})
+	if err != nil {
+		t.Fatalf("拒绝 none 时应换档重试而不是报错：%v", err)
+	}
+	if resp.Text != "处理过期 token" {
+		t.Errorf("正文应正常返回，得 %q", resp.Text)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(bodies) != 2 {
+		t.Fatalf("应请求两次（none 失败 → minimal 重试），得 %d 次", len(bodies))
+	}
+	if bodies[0]["reasoning_effort"] != "none" {
+		t.Errorf("第一次应仍按原口径传 none，得 %v", bodies[0]["reasoning_effort"])
+	}
+	if bodies[1]["reasoning_effort"] != noThinkingFallbackEffort {
+		t.Errorf("重试应换成 %q，得 %v", noThinkingFallbackEffort, bodies[1]["reasoning_effort"])
+	}
+	// 关键：换的是档位，不是模型 —— 用户选的就是这一条配置。
+	if bodies[1]["model"] != "MiniMax-M3.1-Flash" {
+		t.Errorf("不该换模型，得 %v", bodies[1]["model"])
+	}
+}
+
+// 与「关闭思考」无关的 4xx（鉴权 / 模型不存在…）必须原样报错，不许瞎重试。
+func TestConfiguredBadRequestUnrelatedNotRetried(t *testing.T) {
+	var mu sync.Mutex
+	calls := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		calls++
+		mu.Unlock()
+		w.WriteHeader(http.StatusBadRequest)
+		fmt.Fprint(w, `{"error":{"message":"model not found"}}`)
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{{"id": "m1", "url": srv.URL + "/v1", "apiKey": "k"}})
+
+	_, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Complete(context.Background(), Request{
+		Engine: "llm", Model: "m1", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "HTTP 400") {
+		t.Fatalf("无关的 400 应原样报错，得 %v", err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if calls != 1 {
+		t.Errorf("无关错误不该重试，实际请求 %d 次", calls)
+	}
+}
+
+// 配置里显式声明的不思考变体（extraBody.thinking.type=disabled）被端点拒绝时，
+// 那是**配置错误** —— 不许把它悄悄改成 minimal 把真实原因盖住。
+func TestConfiguredDisabledVariantErrorNotRewritten(t *testing.T) {
+	var mu sync.Mutex
+	calls := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		calls++
+		mu.Unlock()
+		w.WriteHeader(http.StatusBadRequest)
+		fmt.Fprint(w, `{"error":{"message":"model \"x\" requires adaptive thinking; `+
+			`thinking.type=\"disabled\" (including reasoning.effort=none) is not allowed (2013)"}}`)
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{
+		{"id": "x-nothink", "model": "x", "url": srv.URL + "/v1", "apiKey": "k",
+			"extraBody": map[string]any{"thinking": map[string]any{"type": "disabled"}}},
+	})
+
+	_, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Complete(context.Background(), Request{
+		Engine: "llm", Model: "x-nothink", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "is not allowed") {
+		t.Fatalf("配置错误应如实报出，得 %v", err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if calls != 1 {
+		t.Errorf("配置声明的不思考变体不该被改写重试，实际请求 %d 次", calls)
+	}
+}
+
+// 流式路径同样要换档重试（两条路径共用 doConfiguredRequestThinkingAware）。
+func TestStreamConfiguredNoThinkingFallsBack(t *testing.T) {
+	var mu sync.Mutex
+	var bodies []map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, _ := io.ReadAll(r.Body)
+		var b map[string]any
+		_ = json.Unmarshal(raw, &b)
+		mu.Lock()
+		bodies = append(bodies, b)
+		mu.Unlock()
+		if b["reasoning_effort"] == "none" {
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, `{"error":{"message":"requires adaptive thinking; reasoning effort none is not allowed (2013)"}}`)
+			return
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		fmt.Fprint(w, "data: {\"choices\":[{\"delta\":{\"content\":\"好\"}}]}\n\n")
+		fmt.Fprint(w, "data: [DONE]\n\n")
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{{"id": "MiniMax-M3.1-Flash", "url": srv.URL + "/v1", "apiKey": "k"}})
+
+	res, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Stream(context.Background(), Request{
+		Engine: "llm", Model: "MiniMax-M3.1-Flash", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	}, nil)
+	if err != nil {
+		t.Fatalf("流式也应在换档后成功：%v", err)
+	}
+	if res.Response.Text != "好" {
+		t.Errorf("正文应为「好」，得 %q", res.Response.Text)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(bodies) != 2 || bodies[1]["reasoning_effort"] != noThinkingFallbackEffort {
+		t.Errorf("流式路径也应换档重试，实际 %d 次、第二次档位 %v", len(bodies), bodies[1]["reasoning_effort"])
+	}
+}
+
 func TestExpandEnvKeep(t *testing.T) {
 	t.Setenv("LLM_TEST_KEY", "secret")
 	cases := map[string]string{

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：