magic-agent 2.3.0 → 2.3.9

package/client-ui-mobile/reqs.js

@@ -5,7 +5,7 @@
  * 现在 index 只留两个空容器（#reqs / #reqDetail）+ 一次 mount，本文件自包含：
  *   · 一级：空间目录（空间 → 模块，功能点不画）；
  *   · 二级：点模块进去，**只看这个模块**的需求列表；
- *   · 「整理」：POST /desk/requirements/consolidate（全量 / 单空间 / 二级页单空间）。
+ *   · 「整理」：POST /desk/requirements/consolidate（全量 / 单空间 / 二级页单模块）。
  *
  * 与宿主（index.html）的边界：只通过 mount(host) 注入的能力交互 ——
  *   getBase / getToken（切环境后是活的，必须 getter，不能传快照）、
@@ -26,6 +26,7 @@
   var REQ_DATA = null;         // 最近一次清单（重画用，避免每次点都重新拉）
   var REQ_BUSY = false;        // 「整理」进行中（防重复点击）
   var REQ_BUSY_LABEL = '全部整理'; // 顶栏按钮的进行中文案（重渲染后要能恢复）
+  var REQ_BUSY_KEY = '';       // 本次整理的组头（空间 key；空 = 全部整理，所有组头都置忙）
   var REQ_OPEN = {};           // 工作区展开状态（key = 工作区 id），与会话列表的 WS_OPEN 同构
   var REQ_ALIVE = null;        // 仍有会话的空间路径集合；null = 拿不到会话清单（不筛）
   var REQ_DETAIL = null;       // 二级视图：{key: 工作区 key, mod: 模块名, ws: 工作区对象}
@@ -41,7 +42,7 @@
     '<div class="history__top">' +
       '<button class="topbar__icon" id="btnReqDetailBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>' +
       '<span class="history__title" id="reqDetailTitle">需求</span>' +
-      '<button class="history__disconnect" id="btnReqDetailSync" type="button">整理</button>' +
+      '<button class="history__disconnect" id="btnReqDetailSync" type="button" title="只整理这个模块">整理</button>' +
     '</div>' +
     '<div class="history__list" id="reqDetailList"></div>';
 
@@ -330,17 +331,19 @@
      服务端按 state 判断走哪条路：
        · 没初始化过 → 先按空间目录反推需求基线（首次可能跑几分钟，按钮要能等）；
        · 已初始化   → 只消费上次整理之后的新会话。
-     入口有两个：
+     入口有三个：
        · 每个空间组头的「整理」——只整理这个空间（用户点哪个就是哪个，不猜）；
-       · 右上角「全部整理」——按空间逐个串行跑一遍，汇总结果（一键触发全部）。
-     两个入口都带「我的 → 默认引擎/模型」，服务端不再自动替换引擎。 */
-  function reqPostConsolidate(ws) {
+       · 二级页右上角「整理」——只整理当前模块（body 带 module，不推进空间游标）；
+       · 一级页右上角「全部整理」——按空间逐个串行跑一遍，汇总结果（一键触发全部）。
+     三个入口都带「我的 → 默认引擎/模型」，服务端不再自动替换引擎。 */
+  function reqPostConsolidate(ws, module) {
     var hdr = { 'Content-Type': 'application/json' };
     if (H.getToken()) hdr['X-Magic-Token'] = H.getToken();
     return fetch(H.getBase() + '/desk/requirements/consolidate', {
       method: 'POST', headers: hdr,
       body: JSON.stringify({
         workspace: ws || '',
+        module: module || '',
         engine: H.getRunPref().engine || '',
         model: (H.getRunPref().engine && H.getRunPref().model) || ''
       })
@@ -354,10 +357,13 @@
       });
   }
 
-  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用。
-     label 只改顶部；组头统一显示「整理中…」/「整理」，不各自变文案。
-     二级页那枚「整理」也跟着禁用 —— 归纳期间它和组头一样不能重复点。 */
-  function reqSetBusy(on, label) {
+  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用（防重复点）。
+     只有**真正在整理的那个入口**显示「整理中…」：
+       · 点某个空间 / 某个模块的「整理」→ 只有这一组的文案变；
+       · 点「全部整理」→ 所有组头一起变（那才是全部在跑）。
+     其余按钮只置灰、保持「整理」—— 否则点一个模块会让人以为所有空间都在整理。 */
+  function reqSetBusy(on, label, busyKey) {
+    if (busyKey === undefined) busyKey = REQ_BUSY_KEY;
     if (on) { if (label !== undefined) REQ_BUSY_LABEL = label; }
     else REQ_BUSY_LABEL = '全部整理';
     var btn = els.sync;
@@ -372,38 +378,43 @@
     }
     Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
       b.disabled = !!on;
-      b.textContent = on ? '整理中…' : '整理';
+      if (!on) { b.textContent = '整理'; return; }
+      b.textContent = (!busyKey || b.getAttribute('data-ws') === busyKey) ? '整理中…' : '整理';
     });
   }
 
-  function consolidateRequirements(target) {
+  /* 整理一个空间（module 为空）或一个模块（module 非空）。
+       · 空间级：消费该空间游标之后的新会话，可能同时更新多个模块；
+       · 模块级：只更新这个模块，**不推进空间游标** —— 别的模块的需求仍留在
+         pending，等空间级「整理」/下一轮自动归纳处理，不会被这一下吞掉。
+     服务端按 state 判断走哪条路：没初始化过 → 先按空间目录反推基线；
+     模块级不会触发首次初始化（目录基线天然是空间级的）。 */
+  function consolidateRequirements(target, module) {
     if (REQ_BUSY || !target) return;
     var ws = target.dir || target.id || '';
     if (!ws) return;
-    var firstTime = target.initialized === false;
-    REQ_BUSY = true;
-    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…');
+    module = String(module || '').trim();
+    var firstTime = target.initialized === false && !module;
     var targetKey = target.id || target.dir || '';
-    var groupBtn = null;
-    Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
-      if (!groupBtn && targetKey && b.getAttribute('data-ws') === targetKey) groupBtn = b;
-    });
-    /* 点的是哪个空间，就只让哪个组头显示「初始化中…」；其它组头保持「整理中…」。 */
-    if (groupBtn) groupBtn.textContent = firstTime ? '初始化中…' : '整理中…';
-    reqPostConsolidate(ws)
+    REQ_BUSY = true;
+    REQ_BUSY_KEY = targetKey;
+    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…', targetKey);
+    reqPostConsolidate(ws, module)
       .then(function (d) {
+        var prefix = module ? '模块「' + module + '」' : '';
         if (d.bootstrap) {
           if (d.created || d.updated) toast('已按空间目录生成需求：新建 ' + (d.created || 0) + ' · 更新 ' + (d.updated || 0));
           else toast('已按空间目录初始化：暂未识别到功能点');
         }
-        else if (d.noop) toast('没有新的对话需要整理');
-        else if (d.updated || d.created) toast('整理完成：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
-        else toast('整理完成');
+        else if (d.noop) toast(prefix ? prefix + '没有新的对话需要整理' : '没有新的对话需要整理');
+        else if (d.updated || d.created) toast((prefix || '整理完成') + '：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
+        else toast(prefix ? prefix + '整理完成' : '整理完成');
         loadRequirements(true);   // 后台刷新（不闪「读取中」）
       })
       .catch(function (e) { toast('整理失败：' + ((e && e.message) || e)); })
       .then(function () {
         REQ_BUSY = false;
+        REQ_BUSY_KEY = '';
         reqSetBusy(false, '全部整理');
       });
   }
@@ -438,10 +449,12 @@
       return;
     }
     REQ_BUSY = true;
+    REQ_BUSY_KEY = '';        // 空 = 全部整理：所有组头一起显示「整理中…」
     reqSetBusy(true, '整理中 0/' + list.length);
     var i = 0, ok = 0, fail = 0, created = 0, updated = 0, firstErr = '';
     function done() {
       REQ_BUSY = false;
+      REQ_BUSY_KEY = '';
       reqSetBusy(false, '全部整理');
       loadRequirements(true);
       if (fail) {
@@ -456,7 +469,7 @@
       REQ_BUSY_LABEL = '整理中 ' + i + '/' + list.length;
       var btn = els.sync;
       if (btn) btn.textContent = REQ_BUSY_LABEL;
-      reqPostConsolidate(w.dir || w.id || '')
+      reqPostConsolidate(w.dir || w.id || '', '')
         .then(function (d) {
           ok++;
           created += Number(d.created) || 0;
@@ -487,13 +500,13 @@
     els.sync = root.querySelector('#btnReqSync');
     els.detailBack = detail.querySelector('#btnReqDetailBack');
     els.detailSync = detail.querySelector('#btnReqDetailSync');
-    /* 两个动作：全部整理 / 返回一级；二级页的「整理」只作用于当前空间
-       （不是全部空间 —— 二级页的作用域就是这个空间，标成「全部整理」会让人以为还是全局动作）。 */
+    /* 两个动作：全部整理 / 返回一级；二级页的「整理」只作用于**当前模块**
+       （不是整空间、更不是全部空间 —— 用户点哪个模块，就只整理哪个模块）。 */
     if (els.sync) els.sync.onclick = function () { consolidateAllRequirements(); };
     if (els.detailBack) els.detailBack.onclick = function () { closeReqDetail(); };
     if (els.detailSync) els.detailSync.onclick = function () {
       if (!REQ_DETAIL || !REQ_DETAIL.ws) return;
-      consolidateRequirements(REQ_DETAIL.ws);
+      consolidateRequirements(REQ_DETAIL.ws, REQ_DETAIL.mod);
     };
   }
 

package/internal/agent/capability.go

@@ -149,6 +149,13 @@ const (
 	FeatureSessionEvents = "feature.session.events"
 	// FeatureSessionControl `--stream --control`：stdin NDJSON 控制通道（打断 / 收工 / 回审批）。
 	FeatureSessionControl = "feature.session.control"
+	// FeatureSessionHosted `--hosted`：这一轮的用户提问由客户端「会话托管」自动发出。
+	//
+	// 为什么归 core：托管本身是**纯客户端策略**（执行仍走普通 ask），但「这句是托管的」
+	// 要写进会话历史，回放时才能把气泡画成「托管发送」而不是「我」—— 历史在 core 手里，
+	// 所以标识只能由 core 落。客户端据此决定要不要把 hosted 透传给 core；老 core 没有
+	// 这个位时插件忽略该字段（实时气泡仍由客户端自己标），不阻断发送。
+	FeatureSessionHosted = "feature.session.hosted"
 	// FeatureSessionTeam `--team`：团队模式（主引擎拆任务、子引擎分头执行、主引擎汇总）。
 	//
 	// 为什么归 core 而不是某个引擎：它是**会话层的一种运行模式**，任何能当主引擎的
@@ -164,5 +171,5 @@ const (
 
 // CoreFeatures 返回 core 自身提供的通道能力（字典序，稳定）。
 func CoreFeatures() []string {
-	return []string{FeatureRequirements, FeatureSessionControl, FeatureSessionEvents, FeatureSessionTeam}
+	return []string{FeatureRequirements, FeatureSessionControl, FeatureSessionEvents, FeatureSessionHosted, FeatureSessionTeam}
 }

package/internal/agent/claude.go

@@ -238,9 +238,11 @@ func (e *ClaudeEngine) buildArgsBase(req Request) []string {
 	if m := stripModelPrefix(req.Model); m != "" {
 		args = append(args, "--model", m)
 	}
-	// 推理档位：claude 的 --effort 只认 low/medium/high/xhigh/max（无 minimal），
-	// 传 minimal 时降级为 low，避免 clap 直接拒绝整轮调用。
-	if lv := ReasoningLevel(req.Reasoning); lv != "" {
+	// 推理 / 思考：建议这类短任务显式关闭（--thinking disabled）；
+	// 其余调用仍按 --effort 档位。两者互斥，关闭时不传 effort，避免又落回默认高档。
+	if req.NoThinking {
+		args = append(args, "--thinking", "disabled")
+	} else if lv := ReasoningLevel(req.Reasoning); lv != "" {
 		if lv == "minimal" {
 			lv = "low"
 		}

package/internal/agent/codebuddy.go

@@ -375,8 +375,12 @@ func (c codebuddyCore) buildArgsBase(req Request) []string {
 		args = append(args, "--model", c.model)
 	}
 	// 推理档位：codebuddy 的 --effort 认 minimal/low/medium/high/xhigh/max。
-	if lv := ReasoningLevel(req.Reasoning); lv != "" {
-		args = append(args, "--effort", lv)
+	// NoThinking 走官方 settings alwaysThinkingEnabled=false（见 agentSettingsPayload），
+	// 不传 --effort off（该值不在 --effort 合法枚举里）。
+	if !req.NoThinking {
+		if lv := ReasoningLevel(req.Reasoning); lv != "" {
+			args = append(args, "--effort", lv)
+		}
 	}
 	// 统一参数矩阵：`--settings` 只接受一份载荷，故 MaxTokens 的 env 注入与
 	// 四档模型的 sandbox / autoMode / permissions 合并进同一个 JSON。

package/internal/agent/codex.go

@@ -540,8 +540,13 @@ func (e *CodexEngine) buildArgs(req Request, prompt, outFile, schemaFile string)
 		}
 	}
 	// 推理档位：`-c` 在 `exec` 与 `exec resume` 下都可用（同 model 覆写），
-	// 故不按子命令分流。codex 的取值：minimal/low/medium/high/xhigh/max。
-	if lv := ReasoningLevel(req.Reasoning); lv != "" {
+	// 故不按子命令分流。codex 的取值：none/minimal/low/medium/high/xhigh/max。
+	// 建议这类短任务用 none 明确关闭思考（不支持 none 的模型会在服务端报错，
+	// 由建议层降级到 llm，不会拖住用户会话）。
+	if req.NoThinking {
+		args = append(args, "-c", "model_reasoning_effort="+tomlBasicString("none"),
+			"-c", "model_reasoning_summary="+tomlBasicString("none"))
+	} else if lv := ReasoningLevel(req.Reasoning); lv != "" {
 		args = append(args, "-c", "model_reasoning_effort="+tomlBasicString(lv))
 	}
 	// SystemPrompt → -c developer_instructions=<TOML 字符串>

package/internal/agent/dsh_sdk.go

@@ -167,6 +167,11 @@ type dshSDKInitParams struct {
 	Provider  string `json:"provider"`
 	Model     string `json:"model"`
 	MaxTokens int    `json:"maxTokens,omitempty"`
+	// ReasoningEffort 为空 = 沿用模型默认；NoThinking 时传官方值 "off"。
+	// 官方依据：dsh-sdk-protocol InitializeParams.reasoningEffort；
+	// dsh-llm-deepseek README："off" 序列化为 thinking.type=disabled。
+	// pi-ai 路由需在 profile 声明 reasoningEfforts.off（本机 sdk patch 已加）。
+	ReasoningEffort string `json:"reasoningEffort,omitempty"`
 }
 
 // dshSDKTextBlock = TextBlock（ContentBlock 的 text 成员）。
@@ -410,6 +415,9 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 
 	// ① initialize：握手失败 = SDK 通道不可用（旧版 dsh 没有该 profile 时会走到这里）。
 	initParams := dshSDKInitParams{Cwd: workspace, Provider: provider, Model: model, MaxTokens: req.MaxTokens}
+	if req.NoThinking {
+		initParams.ReasoningEffort = "off"
+	}
 	initID, err := send("initialize", initParams)
 	if err != nil {
 		return dshSDKTurnResult{}, fmt.Errorf("%w: 写 initialize: %v", errDshSDKUnavailable, err)

package/internal/agent/dsh_sdk_test.go

@@ -261,6 +261,23 @@ func TestDshSDKIgnoresOtherSessions(t *testing.T) {
 	}
 }
 
+// NoThinking：官方 InitializeParams.reasoningEffort=off，不能只靠隐藏事件。
+func TestDshSDKNoThinkingSendsOff(t *testing.T) {
+	dshSDKHome(t, "modelverse", "deepseek-v4.1-flash")
+	dir := t.TempDir()
+	bin, _, stdinLog := dshSDKStub(t, dir, dshSDKStubOpts{})
+
+	if _, err := (&DshEngine{BinPath: bin}).Complete(context.Background(), Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}); err != nil {
+		t.Fatalf("Complete: %v", err)
+	}
+	if got := readFileString(t, stdinLog); !strings.Contains(got, `"reasoningEffort":"off"`) {
+		t.Errorf("initialize 应带 reasoningEffort=off: %s", got)
+	}
+}
+
 // initialize 被服务端明确拒绝（模型没配）→ **真失败**，不静默回退 headless。
 func TestDshSDKInitializeRejectedIsFatal(t *testing.T) {
 	dshSDKHome(t, "modelverse", "no-such-model")

package/internal/agent/engine.go

@@ -154,6 +154,16 @@ type Request struct {
 	//	trae/llm/openclaw/dsh/arkclaw 无对应参数。
 	Reasoning string
 
+	// NoThinking 请求引擎关闭模型思考：
+	//	claude     --thinking disabled（官方）
+	//	codex      -c model_reasoning_effort="none" + model_reasoning_summary="none"
+	//	codebuddy  settings alwaysThinkingEnabled=false（官方 settings / SDK thinking:disabled）
+	//	dsh        InitializeParams.reasoningEffort="off"（官方 SDK；dsh-llm-deepseek 会发 thinking.type=disabled）
+	//	llm        直连请求体传 reasoning_effort="none"；CLI 委托路径传
+	//	           llm 官方 -o reasoning_effort none。不自动换模型。
+	// 其余引擎没有已知开关；调用方（建议生成）仍会标记，失败后再降级 llm。
+	NoThinking bool
+
 	// JSONSchema 是可选的结构化输出约束。
 	//
 	// 各引擎行为：
@@ -274,6 +284,16 @@ type Response struct {
 	Attempts int
 }
 
+// NoThinkingSupportOf 引擎是否有已知的关闭思考手段。
+// 只列官方文档/参数确认过的；未知引擎返回 false，调用方应提示而不是假装关闭。
+func NoThinkingSupportOf(name string) bool {
+	switch name {
+	case "claude", "codex", "codebuddy", "codebuddy-ai", "dsh", "llm":
+		return true
+	}
+	return false
+}
+
 // Engine 是一个 agent CLI 后端的统一抽象。
 type Engine interface {
 	// Name 引擎标识（"claude" / "codebuddy" / "trae"）。

package/internal/agent/engine_test.go

@@ -190,6 +190,42 @@ func TestReasoningEffortArgs(t *testing.T) {
 		t.Errorf("codex model_reasoning_effort 未透传: %v", codexArgs)
 	}
 
+	/* NoThinking（建议生成）：每个有原生开关的引擎都要真的关闭，不能只是 minimal。 */
+	claudeNo := (&ClaudeEngine{}).buildArgsBase(Request{NoThinking: true, Reasoning: "max"})
+	if !hasPair(claudeNo, "--thinking", "disabled") || hasPair(claudeNo, "--effort", "max") {
+		t.Errorf("claude NoThinking 应 --thinking disabled 且不传 effort: %v", claudeNo)
+	}
+	// codebuddy：NoThinking 走官方 settings alwaysThinkingEnabled=false，
+	// 不能再传 --effort xhigh（那会把思考档位又打开）。
+	cbNo := (&CodeBuddyEngine{}).buildArgsBase(Request{NoThinking: true, Reasoning: "xhigh"})
+	if hasPair(cbNo, "--effort", "off") || hasPair(cbNo, "--effort", "xhigh") {
+		t.Errorf("codebuddy NoThinking 不应传 --effort: %v", cbNo)
+	}
+	codexNo := (&CodexEngine{}).buildArgs(Request{NoThinking: true, Reasoning: "max"}, "hi", "", "")
+	if !hasPair(codexNo, "-c", `model_reasoning_effort="none"`) ||
+		!hasPair(codexNo, "-c", `model_reasoning_summary="none"`) ||
+		hasPair(codexNo, "-c", `model_reasoning_effort="max"`) {
+		t.Errorf("codex NoThinking 应 none 且不传 max: %v", codexNo)
+	}
+	// dsh 的 launcher/headless 没有 reasoning 开关：NoThinking 对它保持现状，
+	// 不能塞 --effort（实测启动器报 "--profile <name> is required"）。
+	dshNo := dshHeadlessArgs("headless", "", "hi", false)
+	if len(dshNo) < 3 || dshNo[0] != "--profile" || dshNo[1] != "headless" {
+		t.Errorf("dsh 参数不应被 NoThinking 改坏: %v", dshNo)
+	}
+
+	// 官方关闭思考能力表：只列有依据的；trae/openclaw/arkclaw 不假装支持。
+	for _, e := range []string{"claude", "codex", "codebuddy", "dsh", "llm"} {
+		if !NoThinkingSupportOf(e) {
+			t.Errorf("NoThinkingSupportOf(%s) 应为 true", e)
+		}
+	}
+	for _, e := range []string{"trae", "openclaw", "arkclaw"} {
+		if NoThinkingSupportOf(e) {
+			t.Errorf("NoThinkingSupportOf(%s) 应为 false", e)
+		}
+	}
+
 	// off/none/disabled 一律归一为「不传」。
 	for _, v := range []string{"off", "none", "disabled", " OFF "} {
 		if lv := ReasoningLevel(v); lv != "" {
@@ -893,6 +929,22 @@ func TestCodeBuddyMaxTokensSettings(t *testing.T) {
 	}
 }
 
+// TestCodeBuddyNoThinkingSettings 官方 settings 键：NoThinking 时 alwaysThinkingEnabled=false。
+func TestCodeBuddyNoThinkingSettings(t *testing.T) {
+	dir := t.TempDir()
+	w, log := argsCaptureCLI(t, dir, "codebuddy", `echo '{"type":"result","result":"ok"}'`)
+	if _, err := w.codebuddy().Complete(context.Background(), Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}); err != nil {
+		t.Fatalf("Complete: %v", err)
+	}
+	data, _ := os.ReadFile(log)
+	if !strings.Contains(string(data), `"alwaysThinkingEnabled":false`) {
+		t.Errorf("codebuddy 应写官方 settings alwaysThinkingEnabled=false: %q", data)
+	}
+}
+
 // TestNoSettingsWhenMaxTokensUnset MaxTokens 未设置时不注入 --settings。
 func TestNoSettingsWhenMaxTokensUnset(t *testing.T) {
 	cases := []struct {

package/internal/agent/llmengine.go

@@ -145,6 +145,12 @@ func (e *LLMEngine) buildArgs(req Request, prompt string) []string {
 	if req.Temperature != nil {
 		args = append(args, "-o", "temperature", formatTemperature(*req.Temperature))
 	}
+	if req.NoThinking {
+		// simonw/llm 的官方 model option（llm.datasette.io/en/stable/usage.html：
+		// -o/--option key value，OpenAI 系模型暴露 reasoning_effort）。支持该 option
+		// 的插件会把它发到端点；不支持时直接报错 —— 显式 --disable-thinking 的预期结果。
+		args = append(args, "-o", "reasoning_effort", "none")
+	}
 	return append(args, appendAttachmentSection(prompt, nonImage))
 }
 

package/internal/agent/llmengine_test.go

@@ -104,6 +104,13 @@ func TestLLMBuildArgsModelOptions(t *testing.T) {
 		t.Errorf("buildArgs = %q, want %q (温度 0 必须透传)", got, want)
 	}
 
+	// NoThinking：llm 官方 model option；只在 CLI 委托路径出现
+	got = e.buildArgs(Request{NoThinking: true}, "hi")
+	want = []string{"prompt", "-o", "reasoning_effort", "none", "hi"}
+	if strings.Join(got, "\x00") != strings.Join(want, "\x00") {
+		t.Errorf("buildArgs = %q, want %q", got, want)
+	}
+
 	// 都不给
 	got = e.buildArgs(Request{Model: "minimax-m3"}, "hi")
 	for _, a := range got {

package/internal/agent/llmhttp.go

@@ -92,6 +92,12 @@ func buildConfiguredBody(m LLMConfigModel, req Request, stream bool) (map[string
 	} else if m.Temperature != nil {
 		body["temperature"] = *m.Temperature
 	}
+	if req.NoThinking && !LLMModelDisablesThinking(m) {
+		// 没有同线 no-think 变体时，用 llm/OpenAI 兼容端点认的官方参数。
+		// 若端点不支持该参数会返回 400 —— 这是显式 --disable-thinking 的预期失败，
+		// 不静默退回「假装关闭」。
+		body["reasoning_effort"] = "none"
+	}
 	return body, nil
 }
 

package/internal/agent/llmhttp_test.go

@@ -274,6 +274,33 @@ func TestUnknownModelFallsBackToCLI(t *testing.T) {
 	}
 }
 
+func TestBuildConfiguredBodyNoThinking(t *testing.T) {
+	m := LLMConfigModel{ID: "x", Model: "x", URL: "http://x/v1"}
+	body, err := buildConfiguredBody(m, Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body["reasoning_effort"] != "none" {
+		t.Errorf("没有 no-think 变体时应传 reasoning_effort=none: %#v", body["reasoning_effort"])
+	}
+
+	noThink := LLMConfigModel{ID: "x-nothink", Model: "x", URL: "http://x/v1",
+		ExtraBody: map[string]any{"thinking": map[string]any{"type": "disabled"}}}
+	body, err = buildConfiguredBody(noThink, Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := body["reasoning_effort"]; ok {
+		t.Errorf("已有 thinking.disabled 时不应再塞 reasoning_effort: %#v", body)
+	}
+}
+
 func TestExpandEnvKeep(t *testing.T) {
 	t.Setenv("LLM_TEST_KEY", "secret")
 	cases := map[string]string{

package/internal/agent/llmmodels.go

@@ -76,6 +76,19 @@ func (m LLMConfigModel) Endpoint() string {
 	return strings.TrimRight(u, "/") + "/chat/completions"
 }
 
+// LLMModelDisablesThinking 判断 models.json 条目是否声明了不思考变体
+// （extraBody.thinking.type == "disabled"）。
+func LLMModelDisablesThinking(m 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")
+}
+
 // LLMModelsPath 返回 models.json 的路径（$MAGIC_AGENT_MODELS 优先）。
 func LLMModelsPath() string {
 	if p := strings.TrimSpace(os.Getenv("MAGIC_AGENT_MODELS")); p != "" {

package/internal/agent/permission.go

@@ -383,6 +383,11 @@ func agentSettingsPayload(req Request, engine string) (string, bool) {
 	if env := maxTokensEnv(req.MaxTokens); env != nil {
 		settings["env"] = env
 	}
+	// CodeBuddy 官方 settings 键：始终开启思考。NoThinking 时显式关掉；
+	// 这是 codebuddy CLI 能对模型请求施加的官方开关（SDK 另有 thinking.type=disabled）。
+	if req.NoThinking {
+		settings["alwaysThinkingEnabled"] = false
+	}
 
 	// 沙箱 / autoMode / 权限规则只在真会调用工具时注入。
 	if !toolsIsOff(req) {

package/internal/cli/ask.go

@@ -62,21 +62,22 @@ type askOptions struct {
 	login    string // 拉起某引擎自己的交互式登录会话（--login <engine>）
 	// repairModels 还原被反向同步写坏的桌面端 models.json（--repair-models <engine>）：
 	// 2026-09-30 Windows 事故的收尾手段，见 internal/agent/custom_models.go 的事故还原一节。
-	repairModels string
-	events       bool // --stream 的事件流带契约版本与行号（--events；客户端消费用）
-	control      bool // 从 stdin 读 NDJSON 控制命令（--control；打断 / 收工 / 回审批）
-	jsonOut      bool
-	stream       bool
-	noThinking   bool
-	maxTokens    int
-	temperature  float64
-	tempSet      bool
-	reasoning    string // 推理档位（--reasoning；默认 max）
-	jsonSchema   string // 内联 JSON Schema（仅 llm 引擎走 --schema）
-	session      string // 会话续接 id（空 = 新会话，默认）
-	continueF    bool   // 续接最近一次会话（-c/--continue；不需要 id）
-	workspace    string // 工作目录（-w/--workspace；空 = 用调用方 cwd）
-	stop         string // 停止指定会话/运行（--stop <session_id|run_id>）
+	repairModels    string
+	events          bool // --stream 的事件流带契约版本与行号（--events；客户端消费用）
+	control         bool // 从 stdin 读 NDJSON 控制命令（--control；打断 / 收工 / 回审批）
+	jsonOut         bool
+	stream          bool
+	noThinking      bool // 只隐藏思考事件（--no-thinking，历史语义）
+	disableThinking bool // 请求模型真正关闭思考（--disable-thinking / --no-think）
+	maxTokens       int
+	temperature     float64
+	tempSet         bool
+	reasoning       string // 推理档位（--reasoning；默认 max）
+	jsonSchema      string // 内联 JSON Schema（仅 llm 引擎走 --schema）
+	session         string // 会话续接 id（空 = 新会话，默认）
+	continueF       bool   // 续接最近一次会话（-c/--continue；不需要 id）
+	workspace       string // 工作目录（-w/--workspace；空 = 用调用方 cwd）
+	stop            string // 停止指定会话/运行（--stop <session_id|run_id>）
 	// deleteSession 删除指定会话/运行（--delete-session <session_id|run_id>）：
 	// 登记记录 + 事件日志 + 标题覆盖一起删。与插件的 DELETE /desk/session/{id} 同一份实现
 	// （见 internal/session/delete.go）——「一端删了、另一端还在」的根因就是删除没落在
@@ -118,6 +119,11 @@ type askOptions struct {
 	appendTo     string        // 向常驻会话追加消息（--append <session_id|run_id>）
 	idle         time.Duration // 常驻会话空闲收工时长（--idle，仅 --keep-alive 有效）
 
+	// hosted 本轮提问由客户端「会话托管」自动发送（--hosted，2026-10-23）。
+	// 只写进会话历史的 user 事件做标识，不改变提示词、引擎或权限语义 ——
+	// 执行路径与用户亲手发的完全一样，客户端回放时据此画成「托管发送」。
+	hosted bool
+
 	// 会话标题（2026-10-15；见 internal/session/title.go）。
 	// 归纳口径收进 core 后，客户端不再各自实现 —— 否则 PC 与移动端标题不一致，
 	// 且从移动端发起的会话没人替它归纳。
@@ -171,6 +177,7 @@ type askOptions struct {
 	reqAll          bool          // --requirement-all：全量重放
 	reqEngine       string        // --requirement-engine（默认 llm）
 	reqModel        string        // --requirement-model
+	reqModule       string        // --requirement-module：只整理这个模块
 	reqTimeout      time.Duration // --requirement-timeout
 	reqAuto         bool          // --requirement-auto：自动归纳，不触发首次初始化
 }
@@ -224,6 +231,7 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	f.BoolVar(&opts.keepAlive, "keep-alive", true, "常驻会话：首轮结束后不退出、等 --append 追加（需 --stream）。claude/codebuddy 默认开；dsh 默认关（显式传 --keep-alive 开启）；其余引擎不支持")
 	f.StringVar(&opts.appendTo, "append", "", "向常驻会话追加一条消息：传 session_id 或 run_id，内容用 -p/位置参数给")
 	f.DurationVar(&opts.idle, "idle", 5*time.Minute, "常驻会话空闲收工时长（默认 5m；0 = 本轮结束就收工，追加窗口只在任务运行期间）")
+	f.BoolVar(&opts.hosted, "hosted", false, "仅标记：本轮提问由客户端「会话托管」自动发送（写进会话历史，执行语义不变）")
 	f.IntVar(&opts.maxTokens, "max-tokens", 0, "输出 token 上限（0=不指定；claude/codebuddy 经 --settings 注入，llm 透传，trae/dsh 忽略）")
 	f.Float64Var(&opts.temperature, "temperature", -1, "采样温度（-1=不指定；仅 llm 引擎透传，其余引擎忽略）")
 	f.StringVar(&opts.reasoning, "reasoning", "max", "推理/思考档位: minimal | low | medium | high | xhigh | max | off（默认 max；claude/codebuddy 走 --effort，codex 走 -c model_reasoning_effort；其余引擎无此参数，忽略）")
@@ -242,7 +250,9 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	f.BoolVar(&opts.stream, "stream", false, "流式输出：正文/思考增量实时打到 stdout（text 模式思考走 stderr）")
 	f.BoolVar(&opts.events, "events", false, "配合 --stream：事件流带契约版本与行号（每行加 v / seq，并先发一行 ready），供客户端消费；老消费者不要开（形状与 --stream 不同）")
 	f.BoolVar(&opts.control, "control", false, "配合 --stream：从 stdin 读 NDJSON 控制命令（ping / interrupt / stop / answer），让调用方能打断长任务、回审批")
-	f.BoolVar(&opts.noThinking, "no-thinking", false, "流式模式下不转发思考过程增量")
+	f.BoolVar(&opts.noThinking, "no-thinking", false, "流式模式下不转发思考过程增量（只隐藏，不关闭模型思考）")
+	f.BoolVar(&opts.disableThinking, "disable-thinking", false, "请求引擎关闭模型思考（claude/codex/dsh/codebuddy/llm 各自用官方开关）")
+	f.BoolVar(&opts.disableThinking, "no-think", false, "同 --disable-thinking")
 	bindTeamFlags(cmd, opts)
 	bindRequirementFlags(cmd, opts)
 	bindPermissionFlags(cmd, opts)
@@ -720,7 +730,7 @@ func runStreamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 			}
 			// 附件挂在 user 事件上：引擎事件里没有附件信息（`image` 只对应助手产出），
 			// 只有落这里，历史回放才复原得出「那一轮带了哪张图」。
-			sessionLog.push(sessionEvent{Kind: "user", Text: m.Content, Attachments: req.Attachments})
+			sessionLog.push(sessionEvent{Kind: "user", Text: m.Content, Attachments: req.Attachments, Hosted: opts.hosted})
 		}
 	}
 
@@ -1177,6 +1187,10 @@ func prepareAsk(cmd *cobra.Command, args []string, opts *askOptions) (agent.Engi
 		fmt.Fprintf(cmd.ErrOrStderr(),
 			"magic-agent: 提示：%s 引擎没有推理档位参数，--reasoning %s 已忽略\n", engine.Name(), reasoning)
 	}
+	if opts.disableThinking && !agent.NoThinkingSupportOf(engine.Name()) {
+		fmt.Fprintf(cmd.ErrOrStderr(),
+			"magic-agent: 提示：%s 引擎没有已知的关闭思考参数，--disable-thinking 已忽略\n", engine.Name())
+	}
 	toolsMode, err := parseToolsMode(opts.tools)
 	if err != nil {
 		return nil, "", agent.Request{}, err
@@ -1329,6 +1343,7 @@ func prepareAsk(cmd *cobra.Command, args []string, opts *askOptions) (agent.Engi
 		Continue:     opts.continueF,
 		Workspace:    workspace,
 		Reasoning:    reasoning,
+		NoThinking:   opts.disableThinking,
 		Permission:   tier,
 		PermissionOptions: agent.PermissionOptions{
 			ExcludedCommands:    opts.sandboxExclude,

package/internal/cli/requirements.go

@@ -86,6 +86,7 @@ func runConsolidateRequirements(cmd *cobra.Command, opts *askOptions) error {
 		All:     opts.reqAll,
 		Engine:  opts.reqEngine,
 		Model:   opts.reqModel,
+		Module:  opts.reqModule,
 		Timeout: timeout,
 		Auto:    opts.reqAuto,
 	})
@@ -114,6 +115,7 @@ func bindRequirementFlags(cmd *cobra.Command, opts *askOptions) {
 	f.BoolVar(&opts.reqAll, "requirement-all", false, "配合 --consolidate-requirements：全量重放历史记忆（回填 / 滚动校正）。仍走增量合并，只增不减，不会推翻已有内容")
 	f.StringVar(&opts.reqEngine, "requirement-engine", "", "--consolidate-requirements 用哪个引擎（空 = 自动：首次初始化挑能读目录的引擎，增量归纳用 llm）；客户端应传自己的默认引擎")
 	f.StringVar(&opts.reqModel, "requirement-model", "", "配合 --consolidate-requirements：增量归纳用的模型（空 = 引擎默认；首次目录初始化始终用初始化引擎的默认模型）")
+	f.StringVar(&opts.reqModule, "requirement-module", "", "配合 --consolidate-requirements：只整理这个模块（空 = 整个空间）。不推进空间游标，不触发首次目录初始化")
 	f.DurationVar(&opts.reqTimeout, "requirement-timeout", requirements.DefaultTimeout, "配合 --consolidate-requirements：单次模型调用超时（默认归纳 4m / 首次目录初始化 9m）")
 	f.BoolVar(&opts.reqAuto, "requirement-auto", false, "配合 --consolidate-requirements：自动归纳（不触发首次按目录初始化；插件轮末 / 每日兜底用）")
 }

package/internal/cli/sessionlog.go

@@ -122,6 +122,11 @@ type sessionEvent struct {
 	// （`image` 事件只对应助手**产出**），所以只有落在这里，历史回放才复原得出
 	// 「那一轮用了哪张图」—— 移动端据此在历史气泡里画出缩略图。
 	Attachments []agent.Attachment `json:"attachments,omitempty"`
+	// Hosted 这条用户提问由客户端的「会话托管」自动发出（仅 kind:"user" 有）。
+	// 2026-10-23 只增字段：用户要求「托管发送的要标识 显示时区别于“我”发送」。
+	// 它只影响历史回放的画法（机器人头像 + 「托管发送」小标），不参与执行；
+	// 老日志没有这个字段 = 用户亲手发的，回放与以前一致。
+	Hosted bool `json:"hosted,omitempty"`
 }
 
 // sessionWriter 每条流式调用一个实例；开着就一直 append 到