magic-agent 2.3.0 → 2.3.2

package/internal/requirements/consolidate.go

@@ -128,7 +128,15 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 	if Root() == "" {
 		return Result{Workspace: ws.ID, Dir: ws.Dir, Error: "无法确定需求存储目录"}, fmt.Errorf("requirements: no storage root")
 	}
-	res := Result{Workspace: ws.ID, Dir: ws.Dir}
+	moduleScope := SlugifyModule(opts.Module)
+	res := Result{Workspace: ws.ID, Dir: ws.Dir, Module: moduleScope}
+
+	// 模块级整理只更新已有模块，不接受一个不存在的名字（否则模型会把新需求
+	// 塞进一个凭空的目录，用户在清单里根本找不到它）。
+	if moduleScope != "" && !contains(listModules(ws.ID), moduleScope) {
+		res.Error = "模块不存在: " + opts.Module
+		return res, fmt.Errorf("requirements: module not found: %s", opts.Module)
+	}
 
 	// 锁：同一工作区同时只允许一轮归纳（客户端防抖 + 手动「立即整理」可能撞上）。
 	release, busy := acquireLock(ws.ID)
@@ -152,8 +160,9 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 	/* 首次「整理」：先按空间目录反推一版需求基线，再把旧会话记为已消费。
 	   判断依据是 state.BootstrapAt（不是文档数 / 不是 LastConsolidatedAt）：
 	   自动归纳可能已经产出过几篇文档，但「有没有按目录初始化过」是另一件事。
-	   opts.Auto 的自动路径不初始化 —— 它每轮都可能跑，不能悄悄花几分钟读代码。 */
-	if st.BootstrapAt == 0 && !opts.Auto {
+	   opts.Auto 的自动路径不初始化 —— 它每轮都可能跑，不能悄悄花几分钟读代码。
+	   模块级整理也不初始化：目录基线是空间级的，模块只做增量。 */
+	if st.BootstrapAt == 0 && !opts.Auto && moduleScope == "" {
 		boot, berr := bootstrapWorkspace(ctx, ws, opts)
 		if berr != nil {
 			res.Error = truncRunes(berr.Error(), 240)
@@ -206,8 +215,11 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 	if cursor > len(mem) {
 		cursor = len(mem) // 记忆文件被外部截断 → 游标跟着收敛，不越界
 	}
+	/* 模块级整理**不重放**（--requirement-all 是空间级回填），只看游标之后的
+	   新记忆；也不推进游标，否则别的模块的需求会被这一轮悄悄吞掉。 */
+	replay := opts.All && moduleScope == ""
 	entries := mem[cursor:]
-	if opts.All {
+	if replay {
 		entries = mem
 	}
 	if len(entries) == 0 && !opts.Force {
@@ -218,7 +230,7 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 	}
 
 	use := entries
-	if opts.All {
+	if replay {
 		if len(use) > MaxReplayEntries {
 			use = use[len(use)-MaxReplayEntries:]
 		}
@@ -241,7 +253,7 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 		return res, callErr
 	}
 
-	chunks := chunkEntries(use, opts.All)
+	chunks := chunkEntries(use, replay)
 	merger := newDocMerger(ws.ID)
 	byN := make(map[int]Entry, len(mem))
 	for _, e := range mem {
@@ -256,7 +268,15 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 		// 每片重新读已有文档：上一片刚写的要点必须出现在这一片的「已有需求点」里，
 		// 否则同一件事会被重复追加。
 		docs := featureDocsOf(ws.ID)
-		prompt := buildPrompt(wsName, docs, chunk, listModules(ws.ID), opts.All)
+		modules := listModules(ws.ID)
+		/* 模块级整理：只让模型看到这个模块的已有文档与模块名 ——
+		   否则它会把别的模块的新需求也一起写回来（那正是用户点的这一下
+		   「只整理一个模块」所不能接受的事）。 */
+		if moduleScope != "" {
+			docs = docsOfModule(docs, moduleScope)
+			modules = []string{moduleScope}
+		}
+		prompt := buildPrompt(wsName, docs, chunk, modules, replay, moduleScope)
 		text, err := call(prompt, outSchema)
 		res.Calls++
 		if err != nil {
@@ -276,28 +296,34 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 
 		// 新模块的同义二审：归纳是逐轮独立的，模型容易把同一件事拆成近义模块
 		//（「任务列表」/「对话列表」）。只有确认已有模块里没有同义项时才允许新建。
+		// 模块级整理不新建模块（作用域就是这个已有模块），因而也不做二审。
 		alias := map[string]string{}
-		existing := listModules(ws.ID)
-		newMods := []string{}
-		seenNew := map[string]bool{}
-		for _, o := range outs {
-			m := SlugifyModule(o.Module)
-			if m == "" || seenNew[m] || contains(existing, m) {
-				continue
+		if moduleScope == "" {
+			existing := listModules(ws.ID)
+			newMods := []string{}
+			seenNew := map[string]bool{}
+			for _, o := range outs {
+				m := SlugifyModule(o.Module)
+				if m == "" || seenNew[m] || contains(existing, m) {
+					continue
+				}
+				seenNew[m] = true
+				newMods = append(newMods, m)
+			}
+			if len(newMods) > 0 && len(existing) > 0 {
+				alias = resolveModuleAlias(call, newMods, existing)
 			}
-			seenNew[m] = true
-			newMods = append(newMods, m)
-		}
-		if len(newMods) > 0 && len(existing) > 0 {
-			alias = resolveModuleAlias(call, newMods, existing)
 		}
 
 		for _, o := range outs {
+			if moduleScope != "" && !outputInModule(o, moduleScope, merger) {
+				continue
+			}
 			w := writeFeatureItem(ws.ID, o, &writeCtx{
 				merger: merger,
 				alias:  alias,
 				kind:   "归纳",
-				all:    opts.All,
+				all:    replay,
 				sourcesOf: func(x featureOut) []string {
 					out := make([]string, 0, len(x.Sources))
 					for _, n := range x.Sources {
@@ -324,7 +350,7 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 	}
 
 	consumed := cursor
-	if !opts.All {
+	if !replay && moduleScope == "" {
 		consumed = cursor + len(use)
 		if consumed > len(mem) {
 			consumed = len(mem)
@@ -339,11 +365,11 @@ func Consolidate(ctx context.Context, where string, opts Options) (Result, error
 	}
 	res.OK = true
 	res.Consumed = 0
-	if !opts.All {
+	if !replay && moduleScope == "" {
 		res.Consumed = len(use)
 	}
 	res.Replayed = 0
-	if opts.All {
+	if replay {
 		res.Replayed = len(use)
 	}
 	res.Pending = len(mem) - consumed
@@ -435,12 +461,38 @@ func featureDocsOf(id string) []existsDoc {
 	return out
 }
 
+// docsOfModule 只留某个模块下的已有功能点（模块级整理的作用域）。
+func docsOfModule(docs []existsDoc, module string) []existsDoc {
+	out := make([]existsDoc, 0, len(docs))
+	for _, d := range docs {
+		if SlugifyModule(d.Module) == module {
+			out = append(out, d)
+		}
+	}
+	return out
+}
+
+// outputInModule 一条模型增量是否属于本次模块级整理的作用域。
+//
+// 已有功能点按 name 匹配后以它**当前所属模块**为准（与 writeFeatureItem 同一口径：
+// 文档一旦归类就不搬家）；新功能点才看模型给的 module。
+func outputInModule(o featureOut, scope string, merger *docMerger) bool {
+	name := strings.TrimSpace(truncRunes(strings.TrimSpace(o.Name), TitleMaxChars))
+	if name == "" {
+		return false
+	}
+	if hit, has := merger.match(name); has {
+		return SlugifyModule(hit.Module) == scope
+	}
+	return SlugifyModule(o.Module) == scope
+}
+
 // buildPrompt 组归纳 prompt。
 //
 // 规则段是**产品口径**，不是技术参数：哪些话不能写进需求点（缺陷措辞）、
 // 什么样的模块必须复用、结论与问题的界限。这些是业务项目半年里一条条纠正出来的，
 // 换实现时原样保留，别按自己的口味重写。
-func buildPrompt(wsName string, docs []existsDoc, entries []Entry, modules []string, replay bool) string {
+func buildPrompt(wsName string, docs []existsDoc, entries []Entry, modules []string, replay bool, scope string) string {
 	mods := make([]string, 0, len(modules))
 	for _, m := range modules {
 		if strings.TrimSpace(m) != "" {
@@ -531,9 +583,19 @@ func buildPrompt(wsName string, docs []existsDoc, entries []Entry, modules []str
 			"desc 可用记忆重新校核改写（这是唯一允许改写 desc 的场景），" +
 			"需求点/结论里已有的一字不改照抄、缺的补上。"
 	}
+	/* 模块级整理：模型只该动这一个模块。必须写清楚「别的记忆忽略」——
+	   否则它会把整段对话重新归类，用户点一个模块却把别的模块也改了。 */
+	if scope != "" {
+		rules[0] = "0. **本次只整理模块「" + scope + "」**：只输出属于这个模块的功能点" +
+			"（新功能点的 module 必须逐字写「" + scope + "」，已有功能点沿用它的 name）。" +
+			"不属于这个模块的记忆**一律忽略** —— 它们会在「整理整个空间」时处理。"
+	}
 
 	var b strings.Builder
 	b.WriteString("你是资深产品经理，负责把「对话记忆」归纳成**两级**功能点需求文档的**增量**。工作区：" + wsName + "\n\n")
+	if scope != "" {
+		b.WriteString("【模块级整理】本次作用域：模块「" + scope + "」。\n\n")
+	}
 	b.WriteString("== 已有模块（大功能点 · 一级）==\n")
 	if len(mods) == 0 {
 		b.WriteString("（暂无模块，可新建）")

package/internal/requirements/requirements.go

@@ -127,6 +127,13 @@ type Options struct {
 	Engine string
 	// Model 归纳用哪个模型（空 = 引擎默认）。
 	Model string
+	// Module 只整理这个模块（空 = 整个空间）。
+	//
+	// 语义：只把「属于该模块」的增量写回该模块，**不推进空间游标** ——
+	// 其它模块的记忆仍留在 pending，等空间级「整理」或下一次自动归纳处理。
+	// 因此模块级整理是「只增不减、可重复跑」的，不会吞掉别的模块的需求。
+	// ⚠️ 它不会触发首次目录初始化（目录基线天然是空间级的）。
+	Module string
 	// Timeout 单次调用超时（0 = 归纳 240s；首次目录初始化 9m）。
 	Timeout time.Duration
 	// Auto 自动归纳（插件的轮末防抖 / 每日兜底）。
@@ -141,6 +148,8 @@ type Result struct {
 	// Workspace / Dir 归纳的是哪个工作区。
 	Workspace string `json:"workspace,omitempty"`
 	Dir       string `json:"dir"`
+	// Module 这一轮只整理了哪个模块（空 = 整个空间）。
+	Module string `json:"module,omitempty"`
 	// Noop 没有未归纳记忆、也没要求强制跑（等于什么都没做，不是错）。
 	Noop bool `json:"noop,omitempty"`
 	// Bootstrap 这一轮是否完成了首次初始化。

package/internal/requirements/requirements_test.go

@@ -326,6 +326,27 @@ func TestWorkspacesGroupsAndSorts(t *testing.T) {
 	}
 }
 
+// TestResolveWorkspaceByID 按 ws id 也能解析（客户端手里可能只有 id、没有目录）。
+//
+// 老实现的 safeID 把前缀 `ws-` 里的 w/s 也按十六进制校验，任何 id 都过不了：
+// `--consolidate-requirements ws-xxxx` 直接报「工作区不存在」。
+func TestResolveWorkspaceByID(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj-id")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	e := registerWorkspace(proj)
+	got, ok := resolveWorkspace(e.ID)
+	if !ok || got.ID != e.ID || got.Dir != proj {
+		t.Fatalf("按 id 应解析出 %s/%s，实际 %+v ok=%v", e.ID, proj, got, ok)
+	}
+	// 路径穿越仍要被挡住。
+	if safeID("ws-../../etc") || safeID("ws-") || safeID("x-ws-1") {
+		t.Error("非法 id 必须被拒绝")
+	}
+}
+
 // TestConsolidatePipeline 走完整链路：摄入 → prompt → 模型输出 → 合并 → 游标前进。
 // 模型用假调用器（真实归纳的网络/CLI 由真机验收覆盖），验的是代码这一侧。
 func TestConsolidatePipeline(t *testing.T) {
@@ -411,6 +432,114 @@ func TestConsolidatePipeline(t *testing.T) {
 	}
 }
 
+// TestConsolidateModuleScope 模块级整理只动这个模块，且不推进空间游标。
+//
+// 用户 2026-10-23 报障：「点需求的一个模块的整理却触发了所有的整理」。
+// 这里钉住三件事：
+//   - 模型只看到这个模块的已有文档（看不到别的模块，才不会把别的模块也改了）；
+//   - 模型即使输出别的模块的增量，也不落盘；
+//   - 空间游标不动 —— 别的模块的需求留给空间级整理，不能被这一下吞掉。
+func TestConsolidateModuleScope(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj-module")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-mod", proj, "手机号登录要加验证码", "购物车要支持结算")
+
+	id := DirID(proj)
+	merger := newDocMerger(id)
+	wctx := &writeCtx{merger: merger, kind: "归纳"}
+	for _, o := range []featureOut{
+		{Module: "登录", Name: "手机号登录", Points: []string{"手机号可登录"}},
+		{Module: "支付", Name: "购物车结算", Points: []string{"购物车可结算"}},
+	} {
+		if w := writeFeatureItem(id, o, wctx); !w.ok {
+			t.Fatalf("预置文档失败: %+v", w)
+		}
+	}
+	// 已初始化 + 游标 0：模拟「有一批待整理记忆，已过了首次目录初始化」。
+	if err := writeState(id, state{BootstrapAt: time.Now().UnixMilli(), Sessions: map[string]memCursor{}}); err != nil {
+		t.Fatal(err)
+	}
+
+	old := newCaller
+	defer func() { newCaller = old }()
+	var prompts []string
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		return func(prompt string, schema *agent.JSONSchema) (string, error) {
+			prompts = append(prompts, prompt)
+			return `{"features":[
+				{"module":"登录","name":"手机号登录","points":["支持验证码登录"],"sources":[1]},
+				{"module":"支付","name":"购物车结算","points":["支持优惠券"],"sources":[2]}
+			]}`, nil
+		}, nil
+	}
+
+	res, err := Consolidate(context.Background(), proj, Options{Module: "登录"})
+	if err != nil {
+		t.Fatalf("模块级整理失败: %v", err)
+	}
+	if !res.OK || res.Module != "登录" {
+		t.Fatalf("结果应标明模块级整理: %+v", res)
+	}
+	if res.Consumed != 0 {
+		t.Errorf("模块级整理不该推进游标，实际 consumed=%d", res.Consumed)
+	}
+	if st := readState(id); st.Consumed != 0 {
+		t.Errorf("state 游标不该被模块级整理推进，实际 %d", st.Consumed)
+	}
+	if res.Updated != 1 || res.Created != 0 {
+		t.Errorf("只该更新登录模块的 1 篇，实际 %+v", res)
+	}
+	if len(prompts) != 1 {
+		t.Fatalf("应只调 1 次模型，实际 %d", len(prompts))
+	}
+	if !strings.Contains(prompts[0], "本次只整理模块「登录」") || !strings.Contains(prompts[0], "【模块级整理】") {
+		t.Errorf("prompt 应写明模块作用域:\n%s", prompts[0])
+	}
+	if strings.Contains(prompts[0], "购物车结算") || strings.Contains(prompts[0], "[模块 支付]") {
+		t.Errorf("prompt 不该带出别的模块的文档:\n%s", prompts[0])
+	}
+
+	moduleOf := func(name string) (string, Doc) {
+		for _, f := range listFeatureFiles(id) {
+			if f.Name == name {
+				return f.Module, ParseDoc(readFile(t, f.File))
+			}
+		}
+		t.Fatalf("找不到文档 %s", name)
+		return "", Doc{}
+	}
+	if mod, d := moduleOf("手机号登录"); mod != "登录" || !contains(d.Points, "支持验证码登录") {
+		t.Errorf("登录模块应收到本模块增量，实际［%s］%+v", mod, d.Points)
+	}
+	if _, d := moduleOf("购物车结算"); len(d.Points) != 1 || contains(d.Points, "支持优惠券") {
+		t.Errorf("别的模块不该被模块级整理改动，实际 %+v", d.Points)
+	}
+
+	// 空间级整理仍应消费这批记忆：两个模块都更新，游标前进。
+	res2, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("空间级整理失败: %v", err)
+	}
+	if res2.Consumed != 2 || res2.Updated != 2 {
+		t.Errorf("空间级整理应消费 2 条并更新 2 篇，实际 %+v", res2)
+	}
+	if st := readState(id); st.Consumed != 2 {
+		t.Errorf("空间级整理后游标应为 2，实际 %d", st.Consumed)
+	}
+	if _, d := moduleOf("购物车结算"); !contains(d.Points, "支持优惠券") {
+		t.Errorf("空间级整理应补上支付模块的增量，实际 %+v", d.Points)
+	}
+
+	// 不存在的模块要明确报错，不能凭空建目录。
+	if _, err := Consolidate(context.Background(), proj, Options{Module: "不存在"}); err == nil ||
+		!strings.Contains(err.Error(), "module not found") {
+		t.Errorf("不存在的模块应报错，实际 %v", err)
+	}
+}
+
 // TestConsolidateBootstrapsOnceThenIncremental 首次「整理」按目录反推，之后只处理新会话。
 //
 // 这是 2026-10-22 用户口径的代码化：

package/internal/requirements/store.go

@@ -77,11 +77,19 @@ func registryFile() string { return filepath.Join(Root(), "workspaces.json") }
 
 // safeID 工作区 id 会拼进路径 → 只放行本包生成过的形状（挡目录穿越）。
 func safeID(id string) bool {
-	if !strings.HasPrefix(id, "ws-") || len(id) > 40 {
+	const prefix = "ws-"
+	if !strings.HasPrefix(id, prefix) || len(id) > 40 {
 		return false
 	}
-	for _, r := range id {
-		if (r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') || r == '-' {
+	// 前缀 `ws-` 本身含 w/s，不能拿去跑十六进制校验（老实现的循环把整个 id
+	// 都按 [0-9a-f-] 过滤，于是任何 ws id 都过不了 —— 按 id 整理 workspace
+	// 会报「工作区不存在」）。只校验前缀之后的部分。
+	rest := strings.TrimPrefix(id, prefix)
+	if rest == "" {
+		return false
+	}
+	for _, r := range rest {
+		if (r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') {
 			continue
 		}
 		return false

package/internal/suggest/suggest.go

@@ -162,6 +162,13 @@ func Parse(raw string, count int) []string {
 }
 
 // Generate 跑一次旁路生成。失败时返回空建议 + error（调用方如实降级：不画按钮）。
+//
+// 2026-10-23 用户定调：「建议的生成要走引擎的不启用工具 json 返回的方式，提高速度」。
+// 这里的主路径就是如此：当前引擎（in.Engine）+ ToolsOff + JSONSchema + NoThinking，
+// 各引擎都通过 NoThinking 走官方关闭参数；失败/超时再降级到 llm 的 no-think 变体
+// （纯文本、无工具、1-2s），保证界面不会跟着主引擎的 CLI 一起卡到 20s。
+// `ToolsOff` / `JSONSchema` / `NoThinking` 不是可选项 —— 少任何一条都会把建议变成
+// 一次带工具痕迹（或默认高档思考）的完整 agent 轮次。
 func Generate(ctx context.Context, in Request) (Result, error) {
 	reply := strings.TrimSpace(in.Reply)
 	if reply == "" {
@@ -171,8 +178,7 @@ func Generate(ctx context.Context, in Request) (Result, error) {
 	if name == "" {
 		name = DefaultEngine
 	}
-	engine := agent.Lookup(name)
-	if engine == nil {
+	if agent.Lookup(name) == nil {
 		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
 	}
 	timeout := in.Timeout
@@ -182,11 +188,116 @@ func Generate(ctx context.Context, in Request) (Result, error) {
 	cctx, cancel := context.WithTimeout(ctx, timeout)
 	defer cancel()
 	start := time.Now()
-	runner := &agent.Runner{Engine: engine, Timeout: timeout}
-	resp, err := runner.Run(cctx, agent.Request{
-		Model:      strings.TrimSpace(in.Model),
-		Tools:      agent.ToolsOff,
-		Reasoning:  "off", // 建议要快；思考过程只会拖长等待
+
+	/* 建议一律不思考；所有引擎都尽量走官方开关：
+	   llm 用 no-think 变体 / reasoning_effort=none，claude --thinking disabled，
+	   codex effort=none，codebuddy settings alwaysThinkingEnabled=false，
+	   dsh InitializeParams.reasoningEffort=off。没有可靠开关的引擎（trae/openclaw/arkclaw）
+	   仍会被 NoThinking 标记，失败后再降级 llm；不在这里预先改道。 */
+	/* 主引擎：优先当前引擎（用户要的“引擎 JSON 返回”）。claude / codex 给 10s ——
+	   这是「CLI 启动 + 一次短 JSON」的实测上限；超过 10s 多半是凭据/主会话占用，
+	   继续等只会把界面的 20s 预算吃光。之后才降级到 llm（1-2s），并清掉当前引擎的 model。 */
+	primaryBudget := timeout
+	if name != DefaultEngine && primaryBudget > 10*time.Second {
+		primaryBudget = 10 * time.Second
+	}
+	res, err := tryGenerate(cctx, in, name, primaryBudget, start)
+	if err == nil {
+		return res, nil
+	}
+	if name == DefaultEngine {
+		return Result{}, err
+	}
+
+	/* 降级：给 llm 留一段独立预算（整体仍受 timeout 约束）。主引擎的错误不丢，
+	   只有 fallback 也失败时才报它 —— 至少让调用方知道不是“没有建议”，是真失败。 */
+	remain := timeout - time.Since(start)
+	if remain < 2*time.Second {
+		remain = 2 * time.Second
+	}
+	if remain > 8*time.Second {
+		remain = 8 * time.Second
+	}
+	fallbackIn := in
+	fallbackIn.Model = "" // model 是当前引擎的，不能拿去喂 llm
+	fallback, ferr := tryGenerate(cctx, fallbackIn, DefaultEngine, remain, start)
+	if ferr != nil {
+		return Result{}, err
+	}
+	return fallback, nil
+}
+
+// fastLLMModel 找 models.json 里第一条「不思考」的变体（extraBody.thinking.type=disabled）。
+// 建议是短文本，思考只会把 1s 拖成 4s；有这种条目就用它，不硬编码某个模型 id。
+func fastLLMModel() string {
+	list, err := agent.LoadLLMConfigModels()
+	if err != nil {
+		return ""
+	}
+	for _, m := range list {
+		if llmModelDisablesThinking(m) {
+			return m.ID
+		}
+	}
+	return ""
+}
+
+// llmModelDisablesThinking 判断 models.json 条目是否声明了不思考变体。
+func llmModelDisablesThinking(m agent.LLMConfigModel) bool {
+	if strings.TrimSpace(m.ID) == "" || m.ExtraBody == nil {
+		return false
+	}
+	th, ok := m.ExtraBody["thinking"].(map[string]any)
+	if !ok {
+		return false
+	}
+	return strings.EqualFold(strings.TrimSpace(fmt.Sprint(th["type"])), "disabled")
+}
+
+// noThinkLLMModel 给建议选一个真正不思考的 llm 模型：
+// 用户选的模型本身就是 no-think 变体 → 用它；否则用 models.json 里第一条
+// thinking.disabled 变体；没有变体才退回用户选的模型（无法关闭，至少不阻断）。
+func noThinkLLMModel(selected string) string {
+	selected = strings.TrimSpace(selected)
+	if selected != "" {
+		if m, ok := agent.LookupLLMConfigModel(selected); ok && llmModelDisablesThinking(m) {
+			return m.ID
+		}
+	}
+	if fast := fastLLMModel(); fast != "" {
+		return fast
+	}
+	return selected
+}
+
+// tryGenerate 用指定引擎跑一次 ToolsOff + JSONSchema 的短调用。
+func tryGenerate(ctx context.Context, in Request, name string, budget time.Duration, start time.Time) (Result, error) {
+	engine := agent.Lookup(name)
+	if engine == nil {
+		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
+	}
+	reply := strings.TrimSpace(in.Reply)
+	attemptCtx, cancel := context.WithTimeout(ctx, budget)
+	defer cancel()
+	/* 建议是纯文本短任务，**一律不思考**。Reasoning 只作为没有 NoThinking 通道的
+	   引擎的兜底（minimal 仍比默认高档轻）；能真正关闭的引擎看 NoThinking。 */
+	reasoning := "minimal"
+	model := strings.TrimSpace(in.Model)
+	if name == DefaultEngine {
+		/* 建议一律不思考：llm 有 no-think 变体就用它（默认引擎不配模型时也走这里）。
+		   用户显式选了会思考的模型（如 MiniMax-M3.1-Flash）时，宁可换同文件的
+		   no-think 变体，也不让建议在思考上多花几秒；配置里没有变体才保留原模型。 */
+		model = noThinkLLMModel(model)
+	}
+	runner := &agent.Runner{Engine: engine, Timeout: budget}
+	resp, err := runner.Run(attemptCtx, agent.Request{
+		Model: model,
+		Tools: agent.ToolsOff,
+		/* NoThinking：claude → --thinking disabled，codex → effort none，
+		   llm 换成 thinking.disabled 变体，codebuddy → settings:false，
+		   dsh → initialize.reasoningEffort=off。 */
+		NoThinking: true,
+		Reasoning:  reasoning,
 		MaxTokens:  300,
 		Messages:   []agent.Message{{Role: "user", Content: Prompt(in.User, reply, in.Count)}},
 		JSONSchema: Schema(),

package/internal/suggest/suggest_test.go

@@ -2,6 +2,8 @@ package suggest
 
 import (
 	"context"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -130,6 +132,12 @@ func TestGenerateUsesToolsOffAndNoSession(t *testing.T) {
 	if f.got.JSONSchema == nil || len(f.got.JSONSchema.Required) != 1 {
 		t.Fatalf("缺少结构化输出契约")
 	}
+	if f.got.Reasoning != "minimal" {
+		t.Fatalf("建议调用必须用 minimal 兜底档：%q", f.got.Reasoning)
+	}
+	if !f.got.NoThinking {
+		t.Fatalf("建议调用必须显式 NoThinking（claude/codebuddy/codex/dsh 各自关闭思考）")
+	}
 }
 
 func TestDropCreativeRestarts(t *testing.T) {
@@ -216,3 +224,45 @@ func TestGenerateEmptyReplyShortCircuits(t *testing.T) {
 		t.Fatalf("空正文不该调引擎：%#v %#v", res.Suggestions, f.got.Messages)
 	}
 }
+
+func TestEverySuggestionEngineUsesNoThinking(t *testing.T) {
+	// 官方文档确认 codebuddy 的 alwaysThinkingEnabled / dsh 的 reasoningEffort=off
+	// 都能关思考；建议链路不再把它们预先改道到 llm，而是让引擎自己按 NoThinking 执行。
+	for _, name := range []string{"llm", "claude", "codex", "codebuddy", "dsh"} {
+		f := &fakeEngine{name: name, text: `{"suggestions":["继续"]}`}
+		agent.Register(f)
+		res, err := Generate(context.Background(), Request{Reply: "要我继续吗？", Engine: name})
+		if err != nil {
+			t.Fatalf("%s: Generate: %v", name, err)
+		}
+		if !f.got.NoThinking || len(f.got.Messages) == 0 {
+			t.Fatalf("%s 必须真的执行且带 NoThinking：%#v", name, f.got)
+		}
+		if res.Engine != name {
+			t.Fatalf("%s: 不应预先改道，got engine %q", name, res.Engine)
+		}
+	}
+}
+
+func TestFastLLMModelPicksNoThinkVariant(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "models.json")
+	raw := `[
+		{"id":"slow","model":"MiniMax-M3.1-Flash","url":"http://x/v1","apiKey":"k"},
+		{"id":"fast-nothink","model":"MiniMax-M3","url":"http://x/v1","apiKey":"k",
+		 "extraBody":{"thinking":{"type":"disabled"}}}
+	]`
+	if err := os.WriteFile(p, []byte(raw), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("MAGIC_AGENT_MODELS", p)
+	if got := fastLLMModel(); got != "fast-nothink" {
+		t.Fatalf("fastLLMModel = %q, want fast-nothink", got)
+	}
+	if got := noThinkLLMModel("slow"); got != "fast-nothink" {
+		t.Fatalf("noThinkLLMModel(slow) = %q, want fast-nothink（用户选了会思考的模型也要换成 no-think）", got)
+	}
+	if got := noThinkLLMModel("fast-nothink"); got != "fast-nothink" {
+		t.Fatalf("noThinkLLMModel(fast-nothink) = %q, want 原样保留", got)
+	}
+}

package/npm/apk/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.3.0",
-  "versionCode": 20300,
-  "builtAt": "2026-10-23T00:29:48.082Z"
+  "version": "2.3.2",
+  "versionCode": 20302,
+  "builtAt": "2026-10-23T03:26:46.892Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magic-agent",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "专业的 agent CLI 代理工具 - 统一 claude / codebuddy / trae / llm / codex / openclaw 引擎",
   "license": "MIT",
   "bin": {
@@ -19,7 +19,8 @@
     "check:conv-host": "node tests/check-conv-shared-host.mjs",
     "check:conv-mobile": "node tests/check-conv-mobile-host.mjs",
     "check:conv-comp": "node tests/check-conv-component.mjs",
-    "check:conv-queue": "node tests/check-conv-queue.mjs"
+    "check:conv-queue": "node tests/check-conv-queue.mjs",
+    "check:follow": "node tests/check-follow-retry.mjs"
   },
   "files": [
     "npm/bin/",