magic-agent 2.1.5 → 2.3.2

package/internal/cli/suggest.go

@@ -0,0 +1,98 @@
+package cli
+
+// suggest.go - `--suggest-followups <file|->`：一轮结束后生成「用户下一句」的快捷回复。
+//
+// 为什么要单独一条 CLI（用户 2026-10-23：「在回复结束后 ai 自动生成下一轮的建议，
+// 点击即可发送」）：界面（移动端 / PC）不该自己拼提示词、自己调模型 —— 那样每端一份，
+// 同一轮回答在两处会给出不同建议。口径收进 core 之后只有一份（internal/suggest），
+// 客户端（magic-client 的 /desk/suggest）exec 这一条即可。
+//
+// 与 `--summarize-title` 同一套旁路调用：独立进程、新会话、ToolsOff，不续接当前对话，
+// 因此不会污染用户正在聊的那条上下文；也不写会话登记 / 日志（不经过 ask 主流程）。
+//
+// 退出码：
+//
+//	0  成功（哪怕建议为空数组 —— 「没有下一步」是合法结果，调用方不画按钮）
+//	1  引擎失败（不可用 / 超时 / 报错）
+//	2  参数错（请求 JSON 读不到 / 不合法 / 缺 reply）
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/darren/magic-agent/internal/suggest"
+)
+
+// runSuggestFollowups 读取请求 JSON → 调 suggest.Generate → 打印 JSON 结果。
+func runSuggestFollowups(cmd *cobra.Command, opts *askOptions) error {
+	body, err := readSuggestInput(cmd, opts.suggestInput)
+	if err != nil {
+		return &usageError{err}
+	}
+	/* 引擎：没显式传 -e 时用 llm（纯文本、无工具、没有 CLI 会话副作用，与 --title-engine 同口径）；
+	   传了就以调用方的为准 —— 移动端把当前引擎带下来，用户的机器上一定装过它。 */
+	engine := suggest.DefaultEngine
+	if flagChanged(cmd, "engine") {
+		engine = opts.engine
+	}
+	model := ""
+	if flagChanged(cmd, "model") {
+		model = opts.model
+	}
+	res, err := suggest.Generate(cmd.Context(), suggest.Request{
+		User:    body.User,
+		Reply:   body.Reply,
+		Engine:  engine,
+		Model:   model,
+		Timeout: suggest.DefaultTimeout,
+	})
+	if err != nil {
+		return fmt.Errorf("--suggest-followups: 生成失败: %w", err)
+	}
+	if res.Suggestions == nil {
+		res.Suggestions = []string{}
+	}
+	return printJSON(cmd.OutOrStdout(), res)
+}
+
+// readSuggestInput 读请求 JSON：`-` = stdin，其余按文件路径（支持 `@file` 写法）。
+// 上限 1MB：建议只该带「这一轮」的正文，超了说明调用方把整条会话塞进来了。
+func readSuggestInput(cmd *cobra.Command, spec string) (suggest.RequestBody, error) {
+	var body suggest.RequestBody
+	src := strings.TrimSpace(spec)
+	switch src {
+	case "":
+		return body, fmt.Errorf("--suggest-followups 需要请求 JSON：传文件路径或 \"-\"（stdin）")
+	case "-":
+		b, err := io.ReadAll(io.LimitReader(cmd.InOrStdin(), 1<<20))
+		if err != nil {
+			return body, fmt.Errorf("读 stdin 失败：%w", err)
+		}
+		if err := json.Unmarshal(b, &body); err != nil {
+			return body, fmt.Errorf("stdin 不是合法 JSON：%w", err)
+		}
+	default:
+		path := strings.TrimPrefix(src, "@")
+		if strings.HasPrefix(path, "~/") {
+			if home, herr := os.UserHomeDir(); herr == nil {
+				path = home + path[1:]
+			}
+		}
+		b, err := os.ReadFile(path)
+		if err != nil {
+			return body, fmt.Errorf("读请求文件失败：%w", err)
+		}
+		if err := json.Unmarshal(b, &body); err != nil {
+			return body, fmt.Errorf("请求文件不是合法 JSON：%w", err)
+		}
+	}
+	if strings.TrimSpace(body.Reply) == "" {
+		return body, fmt.Errorf(`请求 JSON 缺少 reply（本轮回答正文）：形如 {"user":"…","reply":"…"}`)
+	}
+	return body, nil
+}

package/internal/cli/suggest_test.go

@@ -0,0 +1,54 @@
+package cli
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/darren/magic-agent/internal/suggest"
+)
+
+// TestSuggestFollowupsJSON 走完整 CLI：读 stdin 的请求 JSON → 假引擎 → 输出建议。
+func TestSuggestFollowupsJSON(t *testing.T) {
+	registerFake(&stringEngine{
+		name: "fake-suggest-cli",
+		text: "这是建议：\n```json\n{\"suggestions\":[\"好的，执行吧\",\"先看一下 diff\"]}\n```",
+	})
+	body := `{"user":"改完了吗","reply":"要我继续吗？"}`
+	out, errOut, err := runAskCmd(t, body, "--suggest-followups", "-", "-e", "fake-suggest-cli")
+	if err != nil {
+		t.Fatalf("suggest: %v（stderr=%s）", err, errOut)
+	}
+	var res suggest.Result
+	if uerr := json.Unmarshal([]byte(out), &res); uerr != nil {
+		t.Fatalf("输出不是 JSON：%v\n%s", uerr, out)
+	}
+	if len(res.Suggestions) != 2 || res.Suggestions[0] != "好的，执行吧" {
+		t.Fatalf("Suggestions = %#v", res.Suggestions)
+	}
+	if res.Engine != "fake-suggest-cli" {
+		t.Fatalf("Engine = %q", res.Engine)
+	}
+}
+
+// TestSuggestFollowupsEmptyReply 没有 reply 是**参数错**，不能当成空建议静默成功。
+func TestSuggestFollowupsEmptyReply(t *testing.T) {
+	_, _, err := runAskCmd(t, `{"user":"只说了一句"}`, "--suggest-followups", "-", "-e", "fake-suggest-cli")
+	if err == nil {
+		t.Fatal("缺 reply 应报参数错")
+	}
+	if !strings.Contains(err.Error(), "reply") {
+		t.Fatalf("报错没说清缺什么：%v", err)
+	}
+}
+
+// TestSuggestFollowupsBadJSON 非法 JSON 也必须明确报错（exit 2 的语义）。
+func TestSuggestFollowupsBadJSON(t *testing.T) {
+	_, _, err := runAskCmd(t, `not json`, "--suggest-followups", "-", "-e", "fake-suggest-cli")
+	if err == nil {
+		t.Fatal("非法 JSON 应报参数错")
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Fatalf("应是 usageError（exit 2），实际 %T: %v", err, err)
+	}
+}

package/internal/cli/team.go

@@ -17,6 +17,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/spf13/cobra"
 
@@ -98,7 +100,50 @@ func runTeamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	// 事件出口：--no-thinking 只压思考。
 	// 团队模式下主会话只出现任务列表快照（KindTasks）与汇总，子任务的过程事件
 	// 走各自子会话的日志（见 team_session.go），不再带 parent 转发进来。
-	emit := func(ev agent.StreamEvent) {
+	//
+	// ⚠️ 登记表的「还活着」靠这里续期（2026-10-22 报障：「团队模式子任务还在跑 主会话
+	// 就说结束了」）。流式路径（ask.go）对**每条事件**都写一次状态，团队路径此前只在
+	// 开跑前写一次 running —— 计划 + 子任务几分钟里 updated_at 一动不动，网关的尾随
+	// 连接（followStateEvery=5s）据 terminalSessionState 判「这一轮已结束」，画面落
+	// 红点收尾行，而子任务进程其实还在跑。团队模式没有 turn_end 可依，所以任何**主会话
+	// 自己发出的事件**（计划、任务列表快照、心跳、汇总）都当成一次「还在跑」。
+	// （h 在下面才建：闭包定义在这里不带值，第一次调用在 beginSession 之后。）
+	var emit func(agent.StreamEvent)
+
+	ctx := cmd.Context()
+	if !opts.keepAlive || flagChanged(cmd, "timeout") {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, opts.timeout)
+		defer cancel()
+	}
+	// --control 的打断：取消 ctx → 在跑的子任务进程组一起收。
+	var cancelAll context.CancelFunc
+	if opts.control {
+		ctx, cancelAll = context.WithCancel(ctx)
+		defer cancelAll()
+	}
+
+	h := beginSession(engine.Name(), req, opts.saveRegistry)
+	/* 团队模式**不挂** spawn hook：登记表里的 pid 必须一直是 magic-agent 自己。
+	   团队路径会多次 spawn 主引擎（计划 / 汇总 / 补充规划），hook 会把 pid 换成
+	   这些**短命**子进程的 pid；第一个（计划阶段）一退，normalizeDead 见 pid 不在
+	   就判整条主会话 gone —— 而此刻子任务正在跑。真机复现：24 分钟的一轮里主会话
+	   在第 32 秒就被判死，直到收尾才写回 done。
+	   子引擎进程不靠这条登记收：它们各有自己的子会话记录（openSubSession），
+	   异常退出时由 orphanSubs 按进程组收。 */
+	_ = withSessionHook
+	if h != nil {
+		// 开跑前就标上：计划阶段可能几十秒，这期间列表里已经能看到这条会话了。
+		h.SetMode(session.ModeTeam)
+		h.Mark(session.StateRunning)
+	}
+	emit = func(ev agent.StreamEvent) {
+		h.Mark(session.StateRunning)
+		/* 续期（2026-10-22 真机复现）：Mark 在新旧状态相同时**不写盘**，所以上面那一句
+		   对「已经 running」的会话等于空操作 —— updated_at 从第一条事件起就冻住了，
+		   网关尾随连接据此判终态，画面在子任务还在跑时就落「这一轮已结束」。
+		   Touch 才是真正的续期；5 秒节流对齐网关的 followStateEvery。 */
+		h.Touch(5 * time.Second)
 		if ev.Kind == agent.KindThinking && opts.noThinking {
 			return
 		}
@@ -136,27 +181,6 @@ func runTeamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 			})
 		}
 	}
-
-	ctx := cmd.Context()
-	if !opts.keepAlive || flagChanged(cmd, "timeout") {
-		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, opts.timeout)
-		defer cancel()
-	}
-	// --control 的打断：取消 ctx → 在跑的子任务进程组一起收。
-	var cancelAll context.CancelFunc
-	if opts.control {
-		ctx, cancelAll = context.WithCancel(ctx)
-		defer cancelAll()
-	}
-
-	h := beginSession(engine.Name(), req, opts.saveRegistry)
-	ctx = withSessionHook(ctx, h)
-	if h != nil {
-		// 开跑前就标上：计划阶段可能几十秒，这期间列表里已经能看到这条会话了。
-		h.SetMode(session.ModeTeam)
-		h.Mark(session.StateRunning)
-	}
 	if sessionLog != nil && h != nil {
 		sessionLog.setRunID(h.RunID())
 	}
@@ -180,6 +204,10 @@ func runTeamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	if h != nil {
 		runID = h.RunID()
 	}
+	/* 本次运行开出来的子会话（按 pid 收进程组用，见 orphanSubs）。
+	   写它的是跑子任务的 goroutine，读的是异常退出那一支 —— 加锁。 */
+	var mu sync.Mutex
+	var subs []*subSession
 	res, err := team.Run(ctx, team.Options{
 		Engine:            engine,
 		Model:             req.Model,
@@ -204,13 +232,48 @@ func runTeamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 		PlanOnly:          opts.teamPlanOnly,
 		Adaptive:          opts.teamAdaptive,
 		// 每个子任务 = 一条普通会话：登记记录 + 自己的日志，父指针挂在本会话下。
+		//
+		// 开出来的子会话都记进 subs：父进程异常退出时要按它们的 pid 收进程组
+		// （见下面的 orphan sweep），否则主会话没了、子引擎还在跑，列表里挂一条永远
+		// running 的子会话。
 		OpenSubSession: func(t team.Task, runDir, engine, model string) team.SubSession {
-			return openSubSession(h, opts.saveRegistry, opts.saveHistory, stderr, t, runDir, engine, model)
+			s := openSubSession(h, opts.saveRegistry, opts.saveHistory, stderr, t, runDir, engine, model)
+			if ss, ok := s.(*subSession); ok && ss != nil {
+				mu.Lock()
+				subs = append(subs, ss)
+				mu.Unlock()
+			}
+			return s
 		},
 		OnEvent: emit,
+		// 计划阶段不发事件的续期（见 team.Options.OnTick）。
+		OnTick: func() { h.Touch(0) },
 	})
+	mu.Lock()
+	running := append([]*subSession(nil), subs...)
+	mu.Unlock()
 	if err != nil {
-		finishSession(h, "", session.StateFailed)
+		/* 异常退出也要有**终态**（2026-10-22）：团队模式没有 turn_end 可依，父进程失败时
+		   一条终态事件都不发 —— 客户端只能看登记表，而登记表停在 running，网关按「还在跑」
+		   一直等（或按内核被杀归一成 gone）。这里补一条 turn_failed：走的是流式路径
+		   同一条收尾口径（turn_failed → 画面一行「本轮异常收尾」），调用方不必再猜。 */
+		interrupted := ctx.Err() != nil
+		reason := ""
+		if interrupted {
+			reason = "已中断（主进程被取消或被杀）"
+		} else {
+			reason = err.Error()
+		}
+		emit(agent.StreamEvent{Kind: agent.KindTurnFailed, Text: reason, Reason: reason})
+		state := session.StateFailed
+		if interrupted {
+			state = session.StateInterrupted
+		}
+		finishSession(h, "", state)
+		/* 子引擎是独立进程组（子会话上下文里挂的 SpawnHook 按组登记 pid）：
+		   父这一轮已经作废，把还在跑的一起收掉 —— 否则会话列表里永远挂着一条 running
+		   的子会话，用户点进去只看到半截过程，而且它会一直烧额度。 */
+		orphanSubs(running)
 		if format == agent.FormatJSON {
 			_ = sink.event(streamErrorPayload(engine.Name(), err))
 			_ = agent.WriteError(stderr, format, engine.Name(), 1, err)
@@ -253,6 +316,30 @@ func runTeamAsk(cmd *cobra.Command, args []string, opts *askOptions) error {
 	return nil
 }
 
+// orphanSubs 收掉还没落定的子会话对应的子引擎进程组。
+//
+// 只在团队这一轮**异常退出**时调：正常收尾时每个子会话都在 runTask 的 end() 里
+// Finish 过（进程已经自己退了）。这里兜的是「父进程这一轮作废、子引擎还在跑」那条路
+// —— 不收就是孤儿进程：它一边烧额度，一边让会话列表里那条子会话永远 running。
+//
+// 幂等：进程已经不在（PIDAlive=false）就只补登记表状态，不再发信号。
+func orphanSubs(list []*subSession) {
+	for _, s := range list {
+		if s == nil {
+			continue
+		}
+		rec := s.h.Record()
+		if rec.PID > 0 && agent.PIDAlive(rec.PID) {
+			_ = agent.KillPID(rec.PID, rec.KillGroup)
+		}
+		s.h.Finish(rec.SessionID, session.StateInterrupted)
+		if s.log != nil {
+			s.log.close()
+			s.log = nil
+		}
+	}
+}
+
 // agentRefs 把子任务结果按「类别 + 引擎 + 模型」归并成登记表里的 Agents。
 //
 // 为什么按类别归并而不是一个任务一条：登记表是列表页的数据源，一个 6 任务的团队会话

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。
@@ -221,6 +228,9 @@ func (s *Service) Handler() http.Handler {
 	// 按**绝对路径**读文本文件（Markdown / 日志 / 源码）：移动端产物卡「查看」在浮层里阅读。
 	mux.HandleFunc("/desk/path-read", s.guard(s.handlePathRead))
 	mux.HandleFunc("/desk/titles", s.guard(s.handleTitles))
+	// 下一轮快捷回复（2026-10-23）：一轮结束后生成 0-3 条「用户下一句」。
+	// 旁路调用 core 的 --suggest-followups（不续接会话），界面点击即发。
+	mux.HandleFunc("/desk/suggest", s.guard(s.handleSuggest))
 	// 移动端「环境配置」（引擎/模型/团队/空间选择）的远端存储：多客户端连同一台桌面时共用一份，
 	// 不再各存各的 localStorage（见 prefs.go）。
 	mux.HandleFunc("/desk/prefs", s.guard(s.handlePrefs))
@@ -1074,6 +1084,8 @@ func truncateForMsg(s string) string {
 // 2026-10-19：实现挪进 `session.Delete`（internal/session/delete.go）—— CLI 新增的
 // `--delete-session` 走的是同一份，两条路不再各写一遍（此前只有本接口能做真删除，
 // 于是桌面端只能在自己本地藏起来，出现「PC 删了、移动端还在」）。
+// 2026-10-23：`session.Delete` 会沿父指针级联删掉团队主会话下的子任务会话，
+// 本接口因此也一并生效（响应多一个只增字段 childSessionsRemoved）。
 func (s *Service) handleSessionDelete(w http.ResponseWriter, r *http.Request) {
 	id, action, ok := parseSessionPath(r.URL.Path)
 	if !ok || action != "" {
@@ -1085,7 +1097,12 @@ func (s *Service) handleSessionDelete(w http.ResponseWriter, r *http.Request) {
 		writeErr(w, http.StatusBadRequest, fmt.Sprintf("删除会话 %s 失败：%v", id, err))
 		return
 	}
-	writeJSON(w, http.StatusOK, map[string]any{"id": res.ID, "recordsRemoved": res.RecordsRemoved})
+	// 子会话计数只增字段（旧客户端忽略）：告诉 UI「这次连子任务一起删了几条」。
+	writeJSON(w, http.StatusOK, map[string]any{
+		"id":                   res.ID,
+		"recordsRemoved":       res.RecordsRemoved,
+		"childSessionsRemoved": res.ChildSessionsRemoved,
+	})
 }
 
 // parseSessionPath 从 `/desk/session/{id}/{action}` 拆出 id 与 action，并做**路径安全校验**。
@@ -1773,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 字段）。
@@ -1870,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 != "" {
@@ -1886,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
@@ -2066,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 来不及写
@@ -2114,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())