magic-agent 1.0.111 → 2.3.0

package/internal/client/service.go

@@ -15,6 +15,7 @@ import (
 	"io"
 	"log"
 	"math"
+	"net"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
@@ -62,6 +63,12 @@ type Options struct {
 	// Token 访问令牌；空 = 启动时随机生成。
 	Token  string
 	Logger *log.Logger
+	// APKPath 可选：要分发给移动端的 APK 路径。空 = 自动在包内 npm/apk/ 下找
+	// （见 apk.go）。显式给路径主要给测试与特殊布局用。
+	APKPath string
+	// Lan 是否绑到了局域网（--lan）。移动端「环境」菜单要靠它拿到手机可用的入口，
+	// 否则用户只能手抄 IP。绑回环时不报（报了也连不上）。
+	Lan bool
 	// BrowseUA 内置浏览器中转使用的 User-Agent；空 = 用内置的 Android Chrome。
 	// 为什么可配：UA 会决定站点给哪一版页面。中国大陆出口 + 移动 UA 时，Google 会跳到
 	// http://www.google.cn/m（该路径本身就是 404）；换成桌面 UA 则走香港跳转、可正常打开。
@@ -88,6 +95,16 @@ type Service struct {
 
 	// 需求自动归纳的调度状态（每工作区一个防抖计时器，见 requirements.go）。
 	reqAuto reqAuto
+
+	// 随包发布的移动端 APK（空 = 这个包里没带）。见 apk.go。
+	apkPath string
+
+	/* 公网入口探测（2026-10-22）：隧道是**壳**起的，插件不知道它的域名，而 quick tunnel
+	   每次启动都换域名。这里缓存 probePublicURL 的结果，让 /desk/health 不必每次都扫端口。 */
+	pubMu   sync.Mutex
+	pubURL  string
+	pubExp  time.Time
+	pubBusy bool
 }
 
 // Contract core `--contract` 里本插件关心的部分。
@@ -134,6 +151,14 @@ func New(opts Options) (*Service, error) {
 		opts.MagicAgent = "magic-agent"
 	}
 	s := &Service{opts: opts, log: opts.Logger, runs: map[string]*askRun{}}
+	// 移动端 APK：显式路径优先；否则在包内 npm/apk/ 找（随 npm 包发布，见 apk.go）。
+	s.apkPath = strings.TrimSpace(opts.APKPath)
+	if s.apkPath == "" {
+		s.apkPath = findBundledAPK()
+	}
+	if s.apkPath != "" {
+		s.log.Printf("移动端 APK：%s（v%s）", s.apkPath, apkVersion(s.apkPath))
+	}
 
 	// 项目后端的反代一次建好：profile 合法就给代理，非法就启动即失败
 	//（地址写错比运行时 502 更容易查——启动日志里说清楚）。
@@ -178,6 +203,10 @@ func (s *Service) Handler() http.Handler {
 	mux := http.NewServeMux()
 	mux.HandleFunc("/desk/health", s.guard(s.handleHealth))
 	mux.HandleFunc("/desk/contract", s.guard(s.handleContract))
+	// 移动端 APK：版本信息 + 安装包本身（版本号跟 npm 包走，见 apk.go）。
+	mux.HandleFunc("/desk/app", s.guard(s.handleAppInfo))
+	// 系统浏览器/下载器带不了自定义头，这个接口靠 guard 支持的 ?token= 过鉴权。
+	mux.HandleFunc("/desk/app.apk", s.guard(s.handleAppAPK))
 	mux.HandleFunc("/desk/engines", s.guard(s.handleEngines))
 	mux.HandleFunc("/desk/profile", s.guard(s.handleProfile))
 	mux.HandleFunc("/desk/modules", s.guard(s.handleModules))
@@ -192,6 +221,12 @@ 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))
 	// 需求聚合（2026-10-22，见 requirements.go）：读清单 / 手动整理一轮。
 	// 自动归纳不在这里 —— 它是每轮 /desk/ask 收尾后的防抖动作。
 	mux.HandleFunc("/desk/requirements", s.guard(s.handleRequirements))
@@ -362,12 +397,171 @@ func (s *Service) handleHealth(w http.ResponseWriter, r *http.Request) {
 		// 而且 HEAD 请求在 WebView 里常被记成 ERR_ABORTED 的失败请求（导航抢跑），
 		// 排查时是纯噪音。探活本来就要打这一枪，顺手带一句最省。
 		"remoteUI": s.hasMobileUI(),
+		// 手机可用的局域网入口（2026-10-22，只增字段，不升 contractVersion）。
+		// 移动端「环境」菜单据此自动给出「公司远程」那条，用户不必手抄 IP。
+		// 只给地址、不带令牌：页面自己握着令牌，别把门锁写进响应体里。
+		// 没绑局域网 / 拿不到网卡地址 → null。
+		"lanUrls": s.lanURLs(r.Host),
+		// 公网入口（2026-10-22）：本机 cloudflared quick tunnel 的域名，空 = 没开公网。
+		// 移动端「公司远程」优先用这条（不在同一个 Wi-Fi 也能连）；拿不到才退回 lanUrls。
+		"publicUrl": s.publicURL(),
 		// 团队角色清单（2026-10-22）：移动端「团队模式」页要按角色配路由，
 		// 角色名不能由客户端硬编码。老 core 没有 teamRoles → null，客户端回落内置清单。
 		"teamRoles": s.contract.TeamRoles,
 	})
 }
 
+// lanURLs 服务端自己上报的手机可用入口（形如 http://10.0.0.5:58849/）。
+//
+// 端口从请求的 Host 里取：服务可能绑 0 端口由系统分配，这里不必再存一份。
+// 只返回地址、不带令牌 —— 页面已经握着令牌，别把门锁写进响应体。
+func (s *Service) lanURLs(hostport string) []string {
+	if !s.opts.Lan {
+		return nil
+	}
+	_, portStr, err := net.SplitHostPort(hostport)
+	if err != nil {
+		return nil
+	}
+	port, err := strconv.Atoi(portStr)
+	if err != nil || port <= 0 {
+		return nil
+	}
+	addrs := LanAddresses(port)
+	out := make([]string, 0, len(addrs))
+	for _, a := range addrs {
+		out = append(out, "http://"+a+"/")
+	}
+	return out
+}
+
+// publicTTL 公网入口探测结果的缓存时长。quick tunnel 换域名只发生在重启/开关时，
+// 两分钟足够新；过期后是**后台**刷新，请求路径上不阻塞。
+const publicTTL = 2 * time.Minute
+
+// quickTunnelPortLo/Hi cloudflared 的本地 metrics 端口范围。
+// 端口由 cloudflared 自己从 20241 起顺延分配（实测 20241–20244），这里留足余量。
+const (
+	quickTunnelPortLo = 20240
+	quickTunnelPortHi = 20280
+)
+
+// publicURL 返回本服务对外的 Cloudflare quick tunnel 地址（形如 https://xxx.trycloudflare.com）。
+//
+// 为什么要探测而不是配置：隧道是**壳（掌天瓶）**起的，插件不知道它的域名；quick tunnel
+// 每次启动都换域名，写死或让用户手抄都不成立。cloudflared 把域名放在本地 metrics 的
+// /quicktunnel 里，扫一小段端口就能拿到候选，再用**本服务自己的令牌**回打一次
+// /desk/health 确认「这条隧道确实指向我」（别人的隧道令牌不同 → 401）。
+//
+// 空返回 = 没开公网 / 还没扫到；调用方（移动端）退回局域网地址，不假装有。
+func (s *Service) publicURL() string {
+	s.pubMu.Lock()
+	cur, exp, busy := s.pubURL, s.pubExp, s.pubBusy
+	s.pubMu.Unlock()
+	if busy || time.Now().Before(exp) {
+		return cur
+	}
+	s.pubMu.Lock()
+	if s.pubBusy {
+		s.pubMu.Unlock()
+		return s.pubURL
+	}
+	s.pubBusy = true
+	s.pubMu.Unlock()
+
+	go func() {
+		u := s.probePublicURL()
+		s.pubMu.Lock()
+		changed := u != s.pubURL
+		s.pubURL = u
+		s.pubExp = time.Now().Add(publicTTL)
+		s.pubBusy = false
+		s.pubMu.Unlock()
+		if changed && s.log != nil {
+			if u == "" {
+				s.log.Printf("公网入口：未发现（本机没有指向本服务的 cloudflared quick tunnel）")
+			} else {
+				s.log.Printf("公网入口：%s", u)
+			}
+		}
+	}()
+	return cur
+}
+
+// probePublicURL 扫 cloudflared 的 metrics 端口，找出指向本服务的那条 quick tunnel。
+func (s *Service) probePublicURL() string {
+	tok := strings.TrimSpace(s.opts.Token)
+	if tok == "" {
+		return ""
+	}
+	hosts := make(chan string, quickTunnelPortHi-quickTunnelPortLo+1)
+	for p := quickTunnelPortLo; p <= quickTunnelPortHi; p++ {
+		go func(port int) {
+			cl := &http.Client{Timeout: 400 * time.Millisecond}
+			resp, err := cl.Get(fmt.Sprintf("http://127.0.0.1:%d/quicktunnel", port))
+			if err != nil {
+				hosts <- ""
+				return
+			}
+			defer resp.Body.Close()
+			var v struct {
+				Hostname string `json:"hostname"`
+			}
+			if resp.StatusCode != http.StatusOK || json.NewDecoder(resp.Body).Decode(&v) != nil {
+				hosts <- ""
+				return
+			}
+			hosts <- strings.TrimSpace(v.Hostname)
+		}(p)
+	}
+	var cands []string
+	for i := 0; i <= quickTunnelPortHi-quickTunnelPortLo; i++ {
+		if h := <-hosts; h != "" {
+			cands = append(cands, h)
+		}
+	}
+	if len(cands) == 0 {
+		return ""
+	}
+
+	// 用本服务的令牌回打一次：只有真正指向本服务的隧道才认这个令牌。
+	var (
+		mu    sync.Mutex
+		found string
+		wg    sync.WaitGroup
+	)
+	for _, h := range cands {
+		wg.Add(1)
+		go func(host string) {
+			defer wg.Done()
+			req, err := http.NewRequest(http.MethodGet, "https://"+host+"/desk/health", nil)
+			if err != nil {
+				return
+			}
+			req.Header.Set("X-Magic-Token", tok)
+			resp, err := (&http.Client{Timeout: 3 * time.Second}).Do(req)
+			if err != nil {
+				return
+			}
+			defer resp.Body.Close()
+			if resp.StatusCode != http.StatusOK {
+				return
+			}
+			var v map[string]any
+			if json.NewDecoder(resp.Body).Decode(&v) != nil || v["ok"] != true {
+				return
+			}
+			mu.Lock()
+			if found == "" {
+				found = "https://" + host
+			}
+			mu.Unlock()
+		}(h)
+	}
+	wg.Wait()
+	return found
+}
+
 // handleContract 原样转发 core 的契约（客户端拿它做能力降级，不需要经过插件再解释一遍）。
 func (s *Service) handleContract(w http.ResponseWriter, r *http.Request) {
 	s.proxyCore(w, r, "--contract")
@@ -883,6 +1077,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 != "" {
@@ -894,7 +1090,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，并做**路径安全校验**。

package/internal/client/suggest.go

@@ -0,0 +1,131 @@
+package client
+
+// suggest.go - `POST /desk/suggest`：生成「下一轮快捷回复」（一轮结束后可点的下一句）。
+//
+// 为什么放在插件而不是各端自己调模型（用户 2026-10-23：「在回复结束后 ai 自动生成
+// 下一轮的建议，点击即可发送」，先给了方案、选了「B. 模型生成」）：
+//  1. 提示词与解析口径只能有一份 —— 移动端 / PC 各写一份，同一轮回答会给出不同建议；
+//  2. 模型调用要落在桌面端（引擎 CLI、凭据、配额都在那台机器上），手机只拿结果；
+//  3. **不续接当前会话**：core 的 `--suggest-followups` 是一次独立旁路调用（ToolsOff、
+//     不带 SessionID），不会把「请生成建议」这类指令写进用户正在聊的上下文。
+//
+// 与 `/desk/session/{id}/title/summarize` 同一套做法：插件 exec core，不自己实现归纳/提炼。
+// 失败一律如实回错（502/504），界面侧静默不画按钮 —— 没有建议是合法结果，不拿模板凑。
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"os/exec"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/darren/magic-agent/internal/suggest"
+)
+
+const (
+	// suggestTimeout 单次生成的超时。界面侧 20s 就放弃（见 conversation.js），
+	// 这里留一点余量，避免「进程还没退、上下文已经被撤」的夹缝报错。
+	suggestTimeout = 25 * time.Second
+	// suggestMaxBody 请求体上限：只该带「这一轮」的问答，超了说明调用方塞了整条会话。
+	suggestMaxBody = 64 << 10
+	// suggestMaxUserRunes / suggestMaxReplyRunes 服务端兜底截断（core 还会再截一次）。
+	suggestMaxUserRunes  = 4000
+	suggestMaxReplyRunes = 16000
+)
+
+// suggestSlots 并发闸：建议是锦上添花，不能因为客户端重试/多开把引擎进程堆起来。
+// 2 = 允许「当前会话收尾」与「刚切过去的另一个会话」各一条，超出直接 429。
+var suggestSlots = make(chan struct{}, 2)
+
+// handleSuggest POST /desk/suggest。
+//
+// 请求：{"user":"用户上一句","reply":"本轮回答正文","engine":"可选","model":"可选"}
+// 响应：{"suggestions":["…", "…"], "engine":"llm", "elapsedMs":1234}
+func (s *Service) handleSuggest(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeErr(w, http.StatusMethodNotAllowed, "POST only")
+		return
+	}
+	var body struct {
+		User   string `json:"user"`
+		Reply  string `json:"reply"`
+		Engine string `json:"engine"`
+		Model  string `json:"model"`
+	}
+	if r.Body != nil {
+		if err := json.NewDecoder(io.LimitReader(r.Body, suggestMaxBody)).Decode(&body); err != nil {
+			writeErr(w, http.StatusBadRequest, "请求体不是合法 JSON："+truncateForMsg(err.Error()))
+			return
+		}
+	}
+	body.Reply = strings.TrimSpace(body.Reply)
+	if body.Reply == "" {
+		writeErr(w, http.StatusBadRequest, `缺少 reply（本轮回答正文）：形如 {"user":"…","reply":"…"}`)
+		return
+	}
+	body.User = clipRunes(strings.TrimSpace(body.User), suggestMaxUserRunes)
+	body.Reply = clipRunes(body.Reply, suggestMaxReplyRunes)
+
+	select {
+	case suggestSlots <- struct{}{}:
+		defer func() { <-suggestSlots }()
+	default:
+		writeErr(w, http.StatusTooManyRequests, "建议生成太频繁：上一轮还没结束，请稍后")
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), suggestTimeout)
+	defer cancel()
+
+	payload, _ := json.Marshal(suggest.RequestBody{User: body.User, Reply: body.Reply})
+	args := []string{"--suggest-followups", "-"}
+	/* 引擎/模型由界面带（当前引擎一定装过）；不传则 core 用 llm（见 runSuggestFollowups）。 */
+	if e := strings.TrimSpace(body.Engine); e != "" {
+		args = append(args, "-e", e)
+	}
+	if m := strings.TrimSpace(body.Model); m != "" {
+		args = append(args, "-m", m)
+	}
+	cmd := exec.CommandContext(ctx, s.opts.MagicAgent, args...)
+	cmd.Stdin = bytes.NewReader(payload)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		if ctx.Err() == context.DeadlineExceeded {
+			writeErr(w, http.StatusGatewayTimeout, "生成建议超时（>25s）：这一轮先不给建议")
+			return
+		}
+		msg := strings.TrimSpace(stderr.String())
+		if msg == "" {
+			msg = strings.TrimSpace(stdout.String())
+		}
+		if msg == "" {
+			msg = err.Error()
+		}
+		writeErr(w, http.StatusBadGateway, "生成建议失败："+truncateForMsg(msg))
+		return
+	}
+	var res suggest.Result
+	if err := json.Unmarshal(stdout.Bytes(), &res); err != nil {
+		// core 换了输出形状就如实报错，别静默回空（那会表现成「功能时灵时不灵」）。
+		writeErr(w, http.StatusBadGateway, "core 回的建议不是 JSON："+truncateForMsg(stdout.String()))
+		return
+	}
+	if res.Suggestions == nil {
+		res.Suggestions = []string{}
+	}
+	writeJSON(w, http.StatusOK, res)
+}
+
+// clipRunes 按 rune 截断（中文不能按字节切）。
+func clipRunes(s string, max int) string {
+	if max <= 0 || utf8.RuneCountInString(s) <= max {
+		return s
+	}
+	return string([]rune(s)[:max])
+}

package/internal/client/suggest_test.go

@@ -0,0 +1,116 @@
+package client
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// fakeSuggestCore 写一个假 core 脚本：记录 argv → 吃掉 stdin → 打印一份建议 JSON。
+func fakeSuggestCore(t *testing.T, dir, scriptBody string) (string, string) {
+	t.Helper()
+	argLog := filepath.Join(dir, "args.txt")
+	p := filepath.Join(dir, "magic-agent")
+	body := "#!/bin/sh\nprintf '%s' \"$*\" > " + argLog + "\ncat >/dev/null\n" + scriptBody + "\n"
+	if err := os.WriteFile(p, []byte(body), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return p, argLog
+}
+
+func TestSuggestEndpoint(t *testing.T) {
+	dir := t.TempDir()
+	core, argLog := fakeSuggestCore(t, dir, `printf '{"suggestions":["好的，执行吧","先看一下 diff"],"engine":"fake","elapsedMs":12}\n'`)
+	s := &Service{opts: Options{MagicAgent: core}}
+
+	req := httptest.NewRequest(http.MethodPost, "/desk/suggest",
+		strings.NewReader(`{"user":"改完了吗","reply":"都改完了，要我继续吗？","engine":"fake-engine","model":"fake-model"}`))
+	rec := httptest.NewRecorder()
+	s.handleSuggest(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("code = %d，body=%s", rec.Code, rec.Body.String())
+	}
+	var res struct {
+		Suggestions []string `json:"suggestions"`
+		Engine      string   `json:"engine"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &res); err != nil {
+		t.Fatalf("响应不是 JSON：%v", err)
+	}
+	if len(res.Suggestions) != 2 || res.Suggestions[0] != "好的，执行吧" {
+		t.Fatalf("suggestions = %#v", res.Suggestions)
+	}
+	args, _ := os.ReadFile(argLog)
+	if !strings.Contains(string(args), "--suggest-followups -") {
+		t.Fatalf("没走 --suggest-followups：%s", args)
+	}
+	if !strings.Contains(string(args), "-e fake-engine") || !strings.Contains(string(args), "-m fake-model") {
+		t.Fatalf("引擎/模型没透传：%s", args)
+	}
+}
+
+func TestSuggestEndpointBadRequests(t *testing.T) {
+	dir := t.TempDir()
+	core, _ := fakeSuggestCore(t, dir, `printf '{"suggestions":[]}\n'`)
+	s := &Service{opts: Options{MagicAgent: core}}
+
+	cases := []struct {
+		name string
+		req  *http.Request
+		code int
+	}{
+		{"GET 不允许", httptest.NewRequest(http.MethodGet, "/desk/suggest", nil), http.StatusMethodNotAllowed},
+		{"缺 reply", httptest.NewRequest(http.MethodPost, "/desk/suggest", strings.NewReader(`{"user":"只说了半句"}`)), http.StatusBadRequest},
+		{"非法 JSON", httptest.NewRequest(http.MethodPost, "/desk/suggest", strings.NewReader(`nope`)), http.StatusBadRequest},
+	}
+	for _, c := range cases {
+		rec := httptest.NewRecorder()
+		s.handleSuggest(rec, c.req)
+		if rec.Code != c.code {
+			t.Errorf("%s：code = %d，期望 %d（body=%s）", c.name, rec.Code, c.code, rec.Body.String())
+		}
+	}
+}
+
+func TestSuggestEndpointCoreFailure(t *testing.T) {
+	dir := t.TempDir()
+	core, _ := fakeSuggestCore(t, dir, "echo 'llm CLI not found' >&2\nexit 3")
+	s := &Service{opts: Options{MagicAgent: core}}
+	rec := httptest.NewRecorder()
+	s.handleSuggest(rec, httptest.NewRequest(http.MethodPost, "/desk/suggest",
+		strings.NewReader(`{"user":"x","reply":"要我继续吗？"}`)))
+	if rec.Code != http.StatusBadGateway {
+		t.Fatalf("code = %d，期望 502", rec.Code)
+	}
+	if !strings.Contains(rec.Body.String(), "llm CLI not found") {
+		t.Fatalf("core 的失败原因没带回：%s", rec.Body.String())
+	}
+}
+
+func TestSuggestEndpointGarbageCoreOutput(t *testing.T) {
+	dir := t.TempDir()
+	core, _ := fakeSuggestCore(t, dir, `printf 'not json\n'`)
+	s := &Service{opts: Options{MagicAgent: core}}
+	rec := httptest.NewRecorder()
+	s.handleSuggest(rec, httptest.NewRequest(http.MethodPost, "/desk/suggest",
+		strings.NewReader(`{"user":"x","reply":"要我继续吗？"}`)))
+	if rec.Code != http.StatusBadGateway {
+		t.Fatalf("code = %d，期望 502", rec.Code)
+	}
+	if !strings.Contains(rec.Body.String(), "不是 JSON") {
+		t.Fatalf("应明确说 core 的输出不是 JSON：%s", rec.Body.String())
+	}
+}
+
+func TestClipRunes(t *testing.T) {
+	if got := clipRunes("一二三四五", 3); got != "一二三" {
+		t.Fatalf("clipRunes = %q", got)
+	}
+	if got := clipRunes("短", 10); got != "短" {
+		t.Fatalf("短文本不该变：%q", got)
+	}
+}

package/internal/session/delete.go

@@ -1,4 +1,4 @@
-// delete.go - 删除一条会话（登记记录 + 事件日志 + 标题覆盖）。
+// delete.go - 删除一条会话（登记记录 + 事件日志 + 标题/状态覆盖，含子任务会话）。
 //
 // 为什么要它（2026-10-19 用户：「从pc端删除的会话移动端还在显示」）：
 // 此前「删除」只发生在**客户端本地**（掌天瓶记一座 localStorage 墓碑、从自己的列表拿掉），
@@ -36,9 +36,17 @@ type DeleteResult struct {
 	LogsRemoved     int    `json:"logs_removed"`
 	TitlesRemoved   int    `json:"titles_removed"`
 	StatusesRemoved int    `json:"statuses_removed"`
+	// ChildSessionsRemoved 连同主会话一起删掉的**子任务会话**条数。
+	//
+	// 团队模式拆出的子任务各是一条普通会话（自己的 run/session、自己的日志），
+	// 靠父指针挂在主会话下；只删主会话会留下「父行没了、子行还挂在空处」的孤儿
+	// （见下面的父子闭包）。这里按**子会话 id** 去重（每轮都带 session_id 时同一条子会话只算 1），
+	// 不是按登记记录计数。
+	ChildSessionsRemoved int `json:"child_sessions_removed"`
 }
 
-// Delete 删掉一条会话：登记记录 + 事件日志 + 标题覆盖。
+// Delete 删掉一条会话：登记记录 + 事件日志 + 标题/状态覆盖。
+// 团队主会话还会沿父指针级联删掉挂在它下面的全部子任务会话。
 // id 可以是 session_id 或 run_id（与 --stop / --session-log 同一套寻址）。
 func Delete(id string) (DeleteResult, error) {
 	out := DeleteResult{ID: strings.TrimSpace(id)}
@@ -57,22 +65,52 @@ func Delete(id string) (DeleteResult, error) {
 		return out, err
 	}
 	/* ① 先收集「这条会话所有可能的名字」：传进来的 id（可能两个都不在登记表里、
-	   只有日志文件在），加上命中记录自己的 session_id 与 run_id。 */
+	   只有日志文件在），加上命中记录自己的 session_id 与 run_id，**以及挂在它下面的
+	   子任务会话**（团队模式，2026-10-23 用户：「删除主会话时要把子任务的会话也删除」）。
+
+	   子任务各是一条普通会话（见 internal/session.Record 的 ParentRunID /
+	   ParentSessionID），删除是物理删除：只删主会话会让子会话既没有父行可挂、
+	   又继续占着列表与磁盘。所以这里找一个**闭包**：
+	     · 同一会话跨轮 —— 任一轮的 run_id / session_id 命中，就把两个名字都收进来；
+	     · 子会话 —— 父指针命中已收名字的记录，把自己的名字也收进来；
+	     · 反复直到不再增长（子任务再拆团队 / 多轮登记都能覆盖）。
+	   只沿父指针向下找，不会反向把父会话带进来：删一条子会话只删它自己。 */
 	names := map[string]bool{out.ID: true}
-	for _, r := range recs {
-		if r.RunID != out.ID && r.SessionID != out.ID {
-			continue
+	children := map[string]bool{} // 子会话计数（按规范 id 去重，同一条子会话多轮只算 1）
+	for {
+		before := len(names)
+		for _, r := range recs {
+			if !names[r.RunID] && !names[r.SessionID] {
+				continue
+			}
+			addDeleteName(names, r.RunID)
+			addDeleteName(names, r.SessionID)
 		}
-		if r.RunID != "" {
-			names[r.RunID] = true
+		for _, r := range recs {
+			if names[r.RunID] || names[r.SessionID] {
+				continue
+			}
+			if !names[r.ParentRunID] && !names[r.ParentSessionID] {
+				continue
+			}
+			key := strings.TrimSpace(r.SessionID)
+			if key == "" {
+				key = strings.TrimSpace(r.RunID)
+			}
+			if key != "" {
+				children[key] = true
+			}
+			addDeleteName(names, r.RunID)
+			addDeleteName(names, r.SessionID)
 		}
-		if r.SessionID != "" {
-			names[r.SessionID] = true
+		if len(names) == before {
+			break
 		}
 	}
+	out.ChildSessionsRemoved = len(children)
 	/* ② 再按名字集合删**这一整条会话**的记录：一条会话每轮落一条（run_id 各不同、
 	   session_id 相同），只删「id 正好等于传进来那个」的那一条，其它轮还在列表里
-	   —— 表现就是「删了没删干净、刷新又冒出来」。 */
+	   —— 表现就是「删了没删干净、刷新又冒出来」。子会话的记录同样按名字集合删除。 */
 	for _, r := range recs {
 		if !names[r.RunID] && !names[r.SessionID] {
 			continue
@@ -124,6 +162,15 @@ func logDirsForDelete(registryDir string) []string {
 	return out
 }
 
+// addDeleteName 把一个 id 收进删除名字集合（空值忽略：老记录可能没有 session_id）。
+func addDeleteName(names map[string]bool, name string) {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return
+	}
+	names[name] = true
+}
+
 // safeDeleteID id 能不能安全地当文件名用：非空、非 `.` / `..`、不含路径分隔符与控制字符。
 func safeDeleteID(id string) bool {
 	if id == "" || id == "." || id == ".." {