magic-agent 2.3.0 → 2.3.2

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 到

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：
 // 「加一个参数 默认不存档」+「会话登记也不需要」）。
 //

package/internal/client/requirements.go

@@ -21,6 +21,7 @@ package client
 // 「一句说完、下一句还没打完」的经验值，期间再来一轮就顺延、合并成一次。
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -82,12 +83,13 @@ func (s *Service) handleRequirements(w http.ResponseWriter, r *http.Request) {
 // handleRequirementsConsolidate POST /desk/requirements/consolidate：
 // 立即归纳一轮（用户点「整理」）。
 //
-// 请求体：{"workspace":"<ws_id|目录>", "force":false, "all":false,
+// 请求体：{"workspace":"<ws_id|目录>", "module":"<模块名>", "force":false,
 //
-//	"engine":"claude", "model":"..."}
+//	"all":false, "engine":"claude", "model":"..."}
 //
 // workspace 留空 = 插件自己的工作目录（与 /desk/health 的 defaultWorkspace 一致 ——
 // 那就是 core 不传 -w 时记录的 cwd）。
+// module 留空 = 整理整个空间；给了就只整理那一个模块（移动端二级页的「整理」）。
 // engine / model 是客户端当前配置的默认引擎与模型（移动端「我的 → 默认引擎」）：
 // 「整理的引擎就是配置的默认引擎」—— 客户端传什么，core 就按什么跑，不再自动替换。
 func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.Request) {
@@ -102,6 +104,7 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 	}
 	var body struct {
 		Workspace string `json:"workspace,omitempty"`
+		Module    string `json:"module,omitempty"`
 		Force     bool   `json:"force,omitempty"`
 		All       bool   `json:"all,omitempty"`
 		Engine    string `json:"engine,omitempty"`
@@ -122,6 +125,7 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 		writeErr(w, http.StatusBadRequest, "workspace 不能为空（传 ws id 或目录）")
 		return
 	}
+	module := strings.TrimSpace(body.Module)
 	engine := strings.TrimSpace(body.Engine)
 	model := strings.TrimSpace(body.Model)
 	if model != "" && engine == "" {
@@ -133,7 +137,7 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 		return
 	}
 	out, err := s.runCoreTimed(r.Context(), reqConsolidateTimeout,
-		consolidateArgs(ws, body.Force, body.All, false, engine, model)...)
+		consolidateArgs(ws, module, body.Force, body.All, false, engine, model)...)
 	if err != nil {
 		code := http.StatusBadGateway
 		if isCoreTimeout(err) {
@@ -150,8 +154,11 @@ func (s *Service) handleRequirementsConsolidate(w http.ResponseWriter, r *http.R
 // engine/model 来自客户端配置的默认引擎（手动「整理」）：传了就用它，core 不再自动换。
 // 自动归纳（auto=true）不传：后台没有「当前设备默认引擎」这个概念，让 core 走自己的
 // 默认（增量用 llm；首次初始化也不会发生，因为 --requirement-auto 明确禁止）。
-func consolidateArgs(ws string, force, all, auto bool, engine, model string) []string {
+func consolidateArgs(ws, module string, force, all, auto bool, engine, model string) []string {
 	args := []string{"--consolidate-requirements", ws}
+	if module != "" {
+		args = append(args, "--requirement-module", module)
+	}
 	if force {
 		args = append(args, "--requirement-force")
 	}
@@ -178,14 +185,27 @@ func (s *Service) runCoreTimed(ctx context.Context, timeout time.Duration, args
 	cmd := exec.CommandContext(ctx, s.opts.MagicAgent, args...)
 	// 与 runCore 同一道保险：core 的后代进程握着管道时 Wait 不能永久挂住。
 	cmd.WaitDelay = 5 * time.Second
-	out, err := cmd.Output()
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
 	if err != nil {
 		if ctx.Err() != nil || errors.Is(err, exec.ErrWaitDelay) {
 			return nil, fmt.Errorf("%w（%s）", errCoreTimeout, timeout)
 		}
+		/* core 失败时也会先把结构化结果写到 stdout（`{ok:false,error:"..."}`），
+		   再返回非零退出码。Output() 会把它丢掉，界面只剩一句「exit status 1」——
+		   用户看不到真正原因（例如「模块不存在」）。这里把 stdout 交回调用方，
+		   由它按 JSON 里的 error 展示；真的一个字都没输出才退化成 stderr/退出码。 */
+		if stdout.Len() > 0 {
+			return stdout.Bytes(), nil
+		}
+		if msg := strings.TrimSpace(stderr.String()); msg != "" {
+			return nil, fmt.Errorf("%s", msg)
+		}
 		return nil, err
 	}
-	return out, nil
+	return stdout.Bytes(), nil
 }
 
 // isCoreTimeout 判断错误链里是不是「等 core 超时」。
@@ -270,7 +290,7 @@ func (s *Service) runAutoConsolidate(ws string) {
 
 	// 归纳是后台行为：**不绑**任何 HTTP 请求的生命周期，用独立 context。
 	ctx, cancel := context.WithTimeout(context.Background(), reqConsolidateTimeout)
-	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, false, false, true, "", "")...)
+	out, err := s.runCoreTimed(ctx, reqConsolidateTimeout, consolidateArgs(ws, "", false, false, true, "", "")...)
 	cancel()
 	if err != nil {
 		s.log.Printf("需求自动归纳失败 %s: %v", ws, err)

package/internal/client/requirements_test.go

@@ -131,6 +131,23 @@ func TestRequirementsConsolidateRoute(t *testing.T) {
 	if !ok {
 		t.Errorf("应透传目录 / force / 配置的默认引擎与模型，实际 %v", readCalls(t, logPath))
 	}
+	// 二级页「整理」：module 要原样透传给 core，否则会退化成整空间。
+	recMod := httptest.NewRecorder()
+	bodyMod := strings.NewReader(`{"workspace":"/proj","module":"登录","engine":"claude"}`)
+	svc.Handler().ServeHTTP(recMod, httptest.NewRequest(http.MethodPost,
+		"/desk/requirements/consolidate?token=tok", bodyMod))
+	if recMod.Code != http.StatusOK {
+		t.Fatalf("模块级归纳应 200，实际 %d: %s", recMod.Code, recMod.Body.String())
+	}
+	var sawModule bool
+	for _, c := range readCalls(t, logPath) {
+		if strings.Contains(c, "--consolidate-requirements /proj --requirement-module 登录") {
+			sawModule = true
+		}
+	}
+	if !sawModule {
+		t.Errorf("应透传 --requirement-module 登录，实际 %v", readCalls(t, logPath))
+	}
 	// 归纳的结果要能解出核心字段（客户端靠它显示「更新/新建/待整理」）。
 	var res struct {
 		OK      bool `json:"ok"`
@@ -141,6 +158,40 @@ func TestRequirementsConsolidateRoute(t *testing.T) {
 	}
 }
 
+// TestRequirementsConsolidateSurfacesCoreError core 失败时先写 JSON 再 exit 1，
+// 插件不能把它吞成「exit status 1」——界面要能显示「模块不存在」这类真正原因。
+func TestRequirementsConsolidateSurfacesCoreError(t *testing.T) {
+	dir := t.TempDir()
+	core := filepath.Join(dir, "magic-agent")
+	script := `#!/bin/sh
+case "$*" in
+  *--contract*)
+    echo '{"contractVersion":2,"features":["feature.session.events","feature.session.control","` + FeatureRequirements + `"],"engines":[]}'
+    exit 0
+    ;;
+  *--consolidate-requirements*)
+    echo '{"ok":false,"workspace":"ws-1","module":"不存在","error":"模块不存在: 不存在"}'
+    exit 1
+    ;;
+esac
+exit 0
+`
+	if err := os.WriteFile(core, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	svc := newTestService(t, core)
+	rec := httptest.NewRecorder()
+	body := strings.NewReader(`{"workspace":"ws-1","module":"不存在"}`)
+	svc.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodPost,
+		"/desk/requirements/consolidate?token=tok", body))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("core 的结构化失败应原样回传，实际 %d: %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "模块不存在") {
+		t.Errorf("应保留 core 的 error 文案，实际 %s", rec.Body.String())
+	}
+}
+
 func TestMaybeAutoConsolidate(t *testing.T) {
 	logPath := filepath.Join(t.TempDir(), "calls.log")
 	core := reqCore(t, `"feature.session.events","feature.session.control",`+

package/internal/client/service.go

@@ -49,6 +49,13 @@ const RequiredContractVersion = 2
 // 没有 events 就没有带游标的事件流，没有 control 就无法打断与回审批。
 var requiredFeatures = []string{"feature.session.events", "feature.session.control"}
 
+// FeatureSessionHosted core 的「会话托管历史标识」能力位（与 internal/agent 同值）。
+//
+// 可选特性：老 core 没有它，插件照常发送，只是不追加 --hosted ——
+// 移动端实时气泡仍由客户端自己标，历史回放则退回「用户亲手发的」画法。
+// 不塞进 requiredFeatures，否则升插件就得同步升 core。
+const FeatureSessionHosted = "feature.session.hosted"
+
 // Options 启动参数。
 type Options struct {
 	// MagicAgent core 可执行文件；空 = 从 PATH 找 magic-agent。
@@ -1783,6 +1790,12 @@ type askRequest struct {
 	// 方式，不是这台机器的属性。开关状态由客户端自己记（localStorage），每轮随 body
 	// 下发 —— core 因此完全无状态，「刚才那条为什么走了团队」在会话登记表里查得到。
 	Team *teamRequest `json:"team,omitempty"`
+	// Hosted 本轮提问由客户端「会话托管」自动发送（2026-10-23，只增字段）。
+	//
+	// 只用于把 `kind:"user"` 历史事件标成 hosted（客户端回放画成「托管发送」），
+	// 不改变执行语义。core 没有 feature.session.hosted 时插件**忽略**它 ——
+	// 实时气泡仍由客户端自己标，老 core 上只是历史回放少一个标识，不该阻断发送。
+	Hosted bool `json:"hosted,omitempty"`
 }
 
 // teamRequest 团队模式的请求体（POST /desk/ask 的 team 字段）。
@@ -1880,7 +1893,7 @@ const (
 //     游标（handleAskEvents 里 `after == 0` 才放行它）；
 //   - `prompt_id` 是客户端去重的键：core 首行到达前客户端会反复以 after=0 轮询，没有它
 //     同一句提问会被画很多遍（见 client-ui/shared/conversation.js 的 render）。
-func (r *askRun) appendPrompt(text string, attachments []string) {
+func (r *askRun) appendPrompt(text string, attachments []string, hosted bool) {
 	atts := make([]map[string]string, 0, len(attachments))
 	for _, p := range attachments {
 		if p = strings.TrimSpace(p); p != "" {
@@ -1896,6 +1909,10 @@ func (r *askRun) appendPrompt(text string, attachments []string) {
 	if len(atts) > 0 {
 		ev["attachments"] = atts
 	}
+	/* 与 core 落盘的同名字段同义：断线续传画回来的那条也要是「托管发送」。 */
+	if hosted {
+		ev["hosted"] = true
+	}
 	b, err := json.Marshal(ev)
 	if err != nil {
 		return
@@ -2076,6 +2093,11 @@ func (s *Service) handleAsk(w http.ResponseWriter, r *http.Request) {
 		args = append(args, "-a", p)
 	}
 	args = append(args, "-p", req.Prompt)
+	/* 托管标识：老 core 不认识 --hosted（exit 2），所以先看能力位；缺了就不传 ——
+	   发送本身不能因为这个**纯显示**字段被阻断（实时气泡由客户端自己标）。 */
+	if req.Hosted && hasStr(s.contract.Features, FeatureSessionHosted) {
+		args = append(args, "--hosted")
+	}
 
 	/* 子进程**不绑 HTTP 请求的生命周期**（2026-10-19）：此前用 r.Context()，手机端 SSE
 	   一断（锁屏 / 切后台 / WebView 回收 / 页面刷新）就会 SIGKILL core —— core 来不及写
@@ -2124,7 +2146,7 @@ func (s *Service) handleAsk(w http.ResponseWriter, r *http.Request) {
 	cmd.Stderr = run.stderr
 	/* 用户这条提问先落进回放缓冲（不进 SSE 直播流）：core 的事件流里没有 user 事件，
 	   断线重连 / 打开运行中会话时补出来的画面会缺「用户问的是什么」。 */
-	run.appendPrompt(req.Prompt, req.Attachments)
+	run.appendPrompt(req.Prompt, req.Attachments, req.Hosted)
 	if err := cmd.Start(); err != nil {
 		writeErr(w, http.StatusBadGateway, "启动 core 失败："+err.Error())
 		return

package/internal/client/service_test.go

@@ -66,6 +66,9 @@ echo '{"v":1,"seq":4,"type":"result","text":"hi"}'
 
 const goodContract = `{"contractVersion":2,"features":["feature.session.events","feature.session.control"],"engines":[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]}`
 
+// hostedContract 多了托管历史标识的能力位（2026-10-23 只增）。
+const hostedContract = `{"contractVersion":2,"features":["feature.session.events","feature.session.control","feature.session.hosted"],"engines":[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]}`
+
 func newTestService(t *testing.T, core string) *Service {
 	t.Helper()
 	svc, err := New(Options{MagicAgent: core, Profile: DefaultProfile(), Token: "tok"})
@@ -418,6 +421,38 @@ func TestAskPassesSaveHistory(t *testing.T) {
 	}
 }
 
+// TestAskPassesHosted 托管自动发送的标识：core 有这个能力位时才透传 --hosted。
+// 它只写会话历史（回放画成「托管发送」），执行语义不变。
+func TestAskPassesHosted(t *testing.T) {
+	svc := newTestService(t, fakeCore(t, hostedContract))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	sse := openSSE(t, srv.URL, "tok", askRequest{Engine: "claude", Prompt: "继续", Hosted: true})
+	defer sse.close()
+	_ = sse.next(t)
+	raw, _ := sse.next(t)["raw"].(string)
+	if !strings.Contains(raw, "--hosted") {
+		t.Errorf("core 支持 feature.session.hosted 时应透传 --hosted，实际 %q", raw)
+	}
+}
+
+// TestAskDropsHostedForOldCore 老 core 不认识 --hosted（会 exit 2），插件必须忽略。
+// 这是**纯显示**字段，不能因为它阻断发送；实时气泡仍由客户端自己标。
+func TestAskDropsHostedForOldCore(t *testing.T) {
+	svc := newTestService(t, fakeCore(t, goodContract))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	sse := openSSE(t, srv.URL, "tok", askRequest{Engine: "claude", Prompt: "继续", Hosted: true})
+	defer sse.close()
+	_ = sse.next(t)
+	raw, _ := sse.next(t)["raw"].(string)
+	if strings.Contains(raw, "--hosted") {
+		t.Errorf("老 core 没有 feature.session.hosted，不该透传 --hosted，实际 %q", raw)
+	}
+}
+
 func TestAskInjectsClientEnv(t *testing.T) {
 	svc := newTestService(t, fakeCore(t, goodContract))
 	srv := httptest.NewServer(svc.Handler())