magic-agent 2.1.5 → 2.3.2

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        选同线 thinking.disabled 变体；没有变体时传 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))
 }
 
@@ -207,6 +213,11 @@ func (e *LLMEngine) ListModels(ctx context.Context) ([]string, error) {
 // --json 输出同 `llm logs --json` 的结构（数组，每项含 response /
 // input_tokens / output_tokens），解析失败时退回纯文本路径，不引入新的失败点。
 func (e *LLMEngine) Complete(ctx context.Context, req Request) (Response, error) {
+	// --disable-thinking：优先换成同一条线上的 no-think 变体（MiniMax-M3.1-Flash
+	// 这类模型对 thinking.disabled 直接 400，不能靠请求体硬塞）。
+	if req.NoThinking {
+		req.Model = NoThinkLLMModel(req.Model)
+	}
 	// 配置文件模型（models.json）：命中 id → 直连端点（见 llmhttp.go）。
 	// 为什么必须按 id：id 唯一，而真实模型名会重复（MiniMax-M3 与 minimax-nothink
 	// 真实名相同，只差 extraBody）—— 用名字做参数就无法区分。
@@ -317,6 +328,9 @@ func parseLLMJSONEntry(raw string) (llmJSONEntry, bool) {
 // Stream 实现 Streamer：llm prompt 默认流式，逐行读纯文本 stdout，
 // thinkSplitter 把标签块路由到 thinking 通道。
 func (e *LLMEngine) Stream(ctx context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
+	if req.NoThinking {
+		req.Model = NoThinkLLMModel(req.Model)
+	}
 	// 配置文件模型：命中 id → 直连 SSE（见 llmhttp.go / completeConfigured 上方注释）
 	if m, ok := ResolveLLMConfigModel(req.Model); ok {
 		return e.streamConfigured(ctx, m, req, onEvent)

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 {
@@ -549,3 +556,20 @@ func TestLLMDetectMissingCli(t *testing.T) {
 		t.Errorf("note = %q, want the missing path", note)
 	}
 }
+
+func TestNoThinkLLMModelPicksAnyVariant(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "models.json")
+	raw := `[
+		{"id":"MiniMax-M3.1-Flash","model":"MiniMax-M3.1-Flash","url":"http://x/v1","apiKey":"k"},
+		{"id":"minimax-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 := NoThinkLLMModel("MiniMax-M3.1-Flash"); got != "minimax-nothink" {
+		t.Fatalf("NoThinkLLMModel = %q, want minimax-nothink", 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,54 @@ 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")
+}
+
+// NoThinkLLMModel 给 --disable-thinking 选 no-think 变体：
+// 用户已选 no-think → 原样；否则先找 WireModel 相同、声明 thinking.disabled 的条目，
+// 再退到任意 no-think 条目（M3.1-Flash 只能换模型才能关思考）。都没有则保留原模型
+// （由调用方决定是否再传 reasoning_effort=none）。
+func NoThinkLLMModel(selected string) string {
+	m, ok := ResolveLLMConfigModel(selected)
+	if !ok {
+		return strings.TrimSpace(selected)
+	}
+	if LLMModelDisablesThinking(m) {
+		return m.ID
+	}
+	list, err := LoadLLMConfigModels()
+	if err != nil {
+		return m.ID
+	}
+	// 先找同一条线上的变体（不换真实模型），再退到任意 no-think 变体 ——
+	// 显式 --disable-thinking 的目标是「不思考」，MiniMax-M3.1-Flash 这类模型
+	// 对 thinking.disabled / reasoning_effort=none 直接 400，只能换到 no-think 条目。
+	for _, alt := range list {
+		if alt.ID == m.ID || alt.WireModel() != m.WireModel() {
+			continue
+		}
+		if LLMModelDisablesThinking(alt) {
+			return alt.ID
+		}
+	}
+	for _, alt := range list {
+		if alt.ID != m.ID && LLMModelDisablesThinking(alt) {
+			return alt.ID
+		}
+	}
+	return m.ID
+}
+
 // 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 与移动端标题不一致，
 	// 且从移动端发起的会话没人替它归纳。
@@ -126,6 +132,11 @@ type askOptions struct {
 	titleForce     bool   // --title-force：已有覆盖也重新归纳
 	titleEngine    string // --title-engine：归纳用哪个引擎（默认 llm）
 
+	// 下一轮建议（2026-10-23；见 internal/suggest）。
+	// 一轮结束后生成 0-3 条「用户下一句」的快捷回复；一次性旁路调用，不续接会话。
+	// 值 = 请求 JSON 的文件路径（"-" = stdin）。
+	suggestInput string // --suggest-followups <file|->：{"user":"…","reply":"…"}
+
 	// 四档权限模型（见 internal/agent/permission.go）。仅 claude / codebuddy 接线。
 	permission     string   // 档位：manual | accept-edits | auto | full
 	sandboxExclude []string // 始终在沙箱外执行的命令（sandbox.excludedCommands）
@@ -166,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：自动归纳，不触发首次初始化
 }
@@ -209,6 +221,7 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	f.StringVar(&opts.sessionTitle, "session-title", "", "读一条会话**已存**的标题（JSON：{id,title}），不调 LLM。没有覆盖时回落到 prompt_head。列表页取标题走这条，别逐行调 --summarize-title")
 	f.BoolVar(&opts.titleForce, "title-force", false, "配合 --summarize-title：已有标题也重新归纳（默认命中缓存就直接返回，省一次 LLM 调用）")
 	f.StringVar(&opts.titleEngine, "title-engine", "llm", "--summarize-title 用哪个引擎归纳（默认 llm：纯文本、不带工具）")
+	f.StringVar(&opts.suggestInput, "suggest-followups", "", "生成下一轮快捷回复：传请求 JSON 的文件路径（\"-\" = stdin）：{\"user\":\"…\",\"reply\":\"…\"}。旁路调用，不续接当前会话；引擎走 -e（默认 llm）")
 	f.Uint64Var(&opts.logAfter, "after", 0, "配合 --session-log：增量续读，只回 seq > N 的事件（另附 count/after/lastSeq/snapshotRequired）")
 	f.Uint64Var(&opts.logBefore, "before", 0, "配合 --session-log：向上翻更早的历史，从文件尾跳过 N 条已画事件再取一页（0 = 最新一页；下一页把返回的 nextBefore 传回来。另附 count/before/nextBefore/firstSeq/more；与 --after 互斥）")
 	f.IntVar(&opts.logLimit, "limit", 200, "配合 --before：每页最多返回多少条事件（默认 200）")
@@ -218,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；其余引擎无此参数，忽略）")
@@ -236,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)
@@ -714,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})
 		}
 	}
 
@@ -1171,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
@@ -1323,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/root.go

@@ -368,6 +368,8 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
   一端删了处处都看不到。与插件的 DELETE /desk/session/{id} 是同一份实现
   （internal/session/delete.go），两条路可互换。
     magic-agent --delete-session <session_id>      # 删掉这条会话（含历史）
+  团队主会话还会沿父指针级联删掉挂在它下面的全部子任务会话（JSON 里
+  child_sessions_removed 是连带删掉的子会话条数）；只删子会话不会带走主会话。
   幂等：id 不认识 / 文件本来就不在 → 退出码 0，JSON 里 records_removed=0。
   ⚠️ 是**物理删除**：删完历史就回放不了了。客户端把它当成「删除」的唯一实现，
      只在本地藏起来（记墓碑）的话，别的客户端照样列着（2026-10-19 用户报的
@@ -477,6 +479,9 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 				return runSummarizeTitle(cmd, opts)
 			case flagChanged(cmd, "session-title"):
 				return runSessionTitle(cmd, opts)
+			case flagChanged(cmd, "suggest-followups"):
+				// 值可以是 "-"（stdin），所以用「传过没有」判，而不是「值非空」。
+				return runSuggestFollowups(cmd, opts)
 			case flagChanged(cmd, "title-force"):
 				// --title-force 只在 --summarize-title 下成立：单给它必然是调用方误解了
 				// （想要「强制重新归纳」却没给 id）。明说，不静默忽略。

package/internal/cli/session.go

@@ -646,24 +646,26 @@ func runDeleteSession(cmd *cobra.Command, opts *askOptions) error {
 	}
 	if opts.output == "text" {
 		_, _ = fmt.Fprintf(cmd.OutOrStdout(),
-			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条 / 状态 %d 条）\n",
-			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved, res.StatusesRemoved)
+			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条 / 状态 %d 条 / 子会话 %d 条）\n",
+			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved, res.StatusesRemoved, res.ChildSessionsRemoved)
 		return nil
 	}
 	out := struct {
-		Type            string `json:"type"`
-		ID              string `json:"id"`
-		RecordsRemoved  int    `json:"records_removed"`
-		LogsRemoved     int    `json:"logs_removed"`
-		TitlesRemoved   int    `json:"titles_removed"`
-		StatusesRemoved int    `json:"statuses_removed"`
+		Type                 string `json:"type"`
+		ID                   string `json:"id"`
+		RecordsRemoved       int    `json:"records_removed"`
+		LogsRemoved          int    `json:"logs_removed"`
+		TitlesRemoved        int    `json:"titles_removed"`
+		StatusesRemoved      int    `json:"statuses_removed"`
+		ChildSessionsRemoved int    `json:"child_sessions_removed"`
 	}{
-		Type:            "delete",
-		ID:              res.ID,
-		RecordsRemoved:  res.RecordsRemoved,
-		LogsRemoved:     res.LogsRemoved,
-		TitlesRemoved:   res.TitlesRemoved,
-		StatusesRemoved: res.StatusesRemoved,
+		Type:                 "delete",
+		ID:                   res.ID,
+		RecordsRemoved:       res.RecordsRemoved,
+		LogsRemoved:          res.LogsRemoved,
+		TitlesRemoved:        res.TitlesRemoved,
+		StatusesRemoved:      res.StatusesRemoved,
+		ChildSessionsRemoved: res.ChildSessionsRemoved,
 	}
 	return writeJSONLine(cmd.OutOrStdout(), out)
 }

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 到

package/internal/cli/sessionlog_user_test.go

@@ -85,6 +85,9 @@ func TestStreamAskPersistsUserMessage(t *testing.T) {
 	if evs[0].SessionID != sid {
 		t.Fatalf("首条应带上 session_id（pending 刷盘时回填），实得 %q", evs[0].SessionID)
 	}
+	if evs[0].Hosted {
+		t.Fatal("普通提问不该带 hosted —— 只有客户端显式传 --hosted 的托管自动发送才标")
+	}
 
 	// ② 引擎事件也都在，且排在 user 之后。
 	sawText := false
@@ -122,6 +125,52 @@ func TestStreamAskPersistsUserMessage(t *testing.T) {
 	}
 }
 
+// TestStreamAskPersistsHostedUserMessage `--hosted` 只给 user 事件加一个标识
+// （2026-10-23 用户：「是托管发送的要标识 显示时区别于“我”发送」）。
+//
+// 标识必须落在**会话历史**里：客户端只画实时那条不够 —— 重开会话时气泡是从
+// kind:"user" 回放出来的，历史没这个字段就又会变回「我」。
+func TestStreamAskPersistsHostedUserMessage(t *testing.T) {
+	dir := t.TempDir()
+	prev := SessionLogDirOverride
+	SessionLogDirOverride = dir
+	defer func() { SessionLogDirOverride = prev }()
+
+	const sid = "sess-hosted-log"
+	const prompt = "继续下一步"
+	registerFake(&userEchoStreamEngine{name: "fake-hosted-log", sessionID: sid})
+
+	if _, _, err := runAskCmd(t, "", "-e", "fake-hosted-log", "--stream", "--save-history", "--hosted", prompt); err != nil {
+		t.Fatalf("--stream --hosted: %v", err)
+	}
+
+	evs, err := ReadSessionLog(dir, sid)
+	if err != nil {
+		t.Fatalf("读回会话日志失败：%v", err)
+	}
+	if len(evs) == 0 || evs[0].Kind != "user" {
+		t.Fatalf("首条应是 user，实得：%s", dumpKinds(evs))
+	}
+	if !evs[0].Hosted {
+		t.Fatal("--hosted 没有写进 user 事件（历史回放会退回「我」发送）")
+	}
+	// 正文不能被标识污染：发给引擎 / 回放的都是原句。
+	if evs[0].Text != prompt {
+		t.Fatalf("user 文本被改动：期望 %q，实得 %q", prompt, evs[0].Text)
+	}
+	raw := readLines(t, filepath.Join(dir, sid+".jsonl"))
+	if len(raw) == 0 {
+		t.Fatal("落盘文件是空的")
+	}
+	var first map[string]any
+	if err := json.Unmarshal([]byte(raw[0]), &first); err != nil {
+		t.Fatal(err)
+	}
+	if first["hosted"] != true {
+		t.Fatalf("落盘 JSON 应带 hosted:true（只增字段），实得 %v", first)
+	}
+}
+
 // TestStreamAskNoArchiveByDefault **默认什么都不存**（用户 2026-10-12：
 // 「加一个参数 默认不存档」+「会话登记也不需要」）。
 //