magic-agent 2.1.5 → 2.3.2

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 == ".." {

package/internal/session/delete_test.go

@@ -69,6 +69,146 @@ func TestDeleteRemovesEverything(t *testing.T) {
 	}
 }
 
+/*
+删除主会话要把**子任务会话**一起删（2026-10-23 用户：「列表中删除主会话时要把
+子任务的会话也删除」）。
+
+	团队模式拆出的子任务是普通会话：各自有登记记录、日志、标题与状态，靠
+	ParentRunID / ParentSessionID 挂在主会话下。只删主会话会留下一批「没有父行可挂、
+	却仍在列表 / 磁盘上」的孤儿 —— 和 2026-10-19「一端删了另一端还在」同一类错位。
+	还要正向确认：删子会话**不该**反向带走主会话。
+*/
+func TestDeleteCascadesToSubSessions(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+
+	parent, err := Begin(BeginOptions{Engine: "claude", PromptHead: "团队主会话"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	parent.Finish("sess-parent", StateDone)
+
+	// 子会话 1：父会话已有 session_id，两个父指针都有。
+	kid1, err := Begin(BeginOptions{
+		Engine: "claude", PromptHead: "子任务 1",
+		ParentRunID: parent.RunID(), ParentSessionID: "sess-parent",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid1.Finish("sess-kid-1", StateDone)
+
+	// 子会话 2：创建时父会话还没拿到 session_id，只能按 parent_run_id 认亲。
+	kid2, err := Begin(BeginOptions{
+		Engine: "codex", PromptHead: "子任务 2", ParentRunID: parent.RunID(),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid2.Finish("sess-kid-2", StateDone)
+
+	// 子会话 1 的第二轮（同 session_id、没有父指针）：按「同会话多轮」也归它。
+	kid1b, err := Begin(BeginOptions{Engine: "claude", PromptHead: "子任务 1 追问", SessionID: "sess-kid-1"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid1b.Finish("sess-kid-1", StateDone)
+
+	// 无关会话：同引擎、同目录，但不是这条主会话的子会话 —— 必须留下。
+	other, err := Begin(BeginOptions{Engine: "claude", PromptHead: "无关会话"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	other.Finish("sess-other", StateDone)
+
+	// 每个名字都落一份日志（run_id 与 session_id 两种命名都覆盖）。
+	names := []string{
+		parent.RunID(), "sess-parent",
+		kid1.RunID(), "sess-kid-1", kid1b.RunID(),
+		kid2.RunID(), "sess-kid-2",
+		other.RunID(), "sess-other",
+	}
+	for _, name := range names {
+		if err := os.WriteFile(filepath.Join(dir, name+".jsonl"), []byte("{\"seq\":1}\n"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, id := range []string{"sess-parent", "sess-kid-1", "sess-kid-2", "sess-other"} {
+		if err := SetTitle(id, "标题 "+id); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	res, err := Delete("sess-parent")
+	if err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	// parent + kid1 / kid1b / kid2 共 4 条记录；无关会话不算。
+	if res.RecordsRemoved != 4 {
+		t.Errorf("登记记录删了 %d 条，want 4（主会话 + 3 条子会话记录）", res.RecordsRemoved)
+	}
+	if res.ChildSessionsRemoved != 2 {
+		t.Errorf("子会话删了 %d 条，want 2（sess-kid-1 / sess-kid-2）", res.ChildSessionsRemoved)
+	}
+	if res.LogsRemoved != 7 {
+		t.Errorf("日志删了 %d 份，want 7（主/子会话的 run_id 与 session_id 两个名字）", res.LogsRemoved)
+	}
+	if res.TitlesRemoved != 3 {
+		t.Errorf("标题清了 %d 条，want 3（主会话 + 两个子会话）", res.TitlesRemoved)
+	}
+
+	recs, _ := List()
+	if len(recs) != 1 || recs[0].RunID != other.RunID() {
+		t.Fatalf("登记表应只剩无关会话 %s，实得 %+v", other.RunID(), recs)
+	}
+	for _, name := range []string{
+		parent.RunID(), "sess-parent",
+		kid1.RunID(), "sess-kid-1", kid1b.RunID(),
+		kid2.RunID(), "sess-kid-2",
+	} {
+		if fileExists(filepath.Join(dir, name+".jsonl")) {
+			t.Errorf("日志 %s.jsonl 还在（子会话必须跟着主会话一起删）", name)
+		}
+	}
+	if !fileExists(filepath.Join(dir, other.RunID()+".jsonl")) {
+		t.Error("无关会话的日志被误删了")
+	}
+	for _, id := range []string{"sess-parent", "sess-kid-1", "sess-kid-2"} {
+		if got := TitleFor(id); got != "" {
+			t.Errorf("标题 %s 还有 %q，want 空", id, got)
+		}
+		if got := StatusFor(id); got != "" {
+			t.Errorf("状态 %s 还有 %q，want 空", id, got)
+		}
+	}
+	if TitleFor("sess-other") == "" || StatusFor("sess-other") == "" {
+		t.Error("无关会话的标题 / 状态被误删了")
+	}
+}
+
+// 删子会话只删它自己 —— 父指针是单向认亲，不能反向把主会话带走。
+func TestDeleteSubSessionKeepsParent(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	parent, err := Begin(BeginOptions{Engine: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	parent.Finish("sess-parent", StateDone)
+	kid, err := Begin(BeginOptions{Engine: "claude", ParentRunID: parent.RunID(), ParentSessionID: "sess-parent"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid.Finish("sess-kid", StateDone)
+
+	if _, err := Delete("sess-kid"); err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	recs, _ := List()
+	if len(recs) != 1 || recs[0].SessionID != "sess-parent" {
+		t.Fatalf("删子会话后应只剩主会话，实得 %+v", recs)
+	}
+}
+
 /*
 幂等：id 不认识 / 文件本来就不在 / 再删一次 —— 都算成功。
 

package/internal/session/session.go

@@ -323,6 +323,8 @@ type Handle struct {
 	// 照常接受 pid / 状态 / 收尾回写，只是**不写文件** —— 调用方（CLI 默认）
 	// 因此不留痕，而 run_id 仍能当追加入口的地址（见 AppendSocketPath）。
 	noPersist bool
+	// lastTouch 上次 Touch 续期的时间（节流用，见 Touch）。
+	lastTouch time.Time
 }
 
 // RunID 本次运行的 id。
@@ -379,6 +381,29 @@ func (h *Handle) Mark(state string) {
 	h.write()
 }
 
+// Touch 续期一条活着的会话：只刷新 updated_at，状态不变。
+//
+// 为什么 Mark 不够（2026-10-22 真机复现）：Mark 在「新旧状态相同」时直接 return，
+// 一次盘都不写 —— 调用方以为自己在「每来一条事件就续一次期」，实际上 updated_at
+// 从第一条事件起就冻住了。别端的尾随连接（followStateEvery=5s）靠 updated_at 判活，
+// 团队模式计划 + 子任务几分钟不动，就被归一成 gone，画面提前落「这一轮已结束」。
+//
+// 节流：调用方可能每秒来几十条事件，没必要每条都落盘；minGap 内直接跳过。
+// 状态已进终态（或进程已不在）时不动 —— 终态是结论，不许被心跳续活。
+func (h *Handle) Touch(minGap time.Duration) {
+	if h == nil || h.noPersist {
+		return
+	}
+	if !isLiveState(normalizeState(h.rec.State)) {
+		return
+	}
+	if !h.lastTouch.IsZero() && time.Since(h.lastTouch) < minGap {
+		return
+	}
+	h.lastTouch = time.Now()
+	h.write()
+}
+
 // Finish 收尾：写最终状态（done / failed / cancelled / interrupted）+ 回填会话 id。
 //
 // 一个刻意的小保护：被别人 `--stop` 停掉、或用户中途打断时，磁盘上已经是

package/internal/session/session_mark_test.go

@@ -3,6 +3,7 @@ package session
 import (
 	"os"
 	"testing"
+	"time"
 )
 
 /* Handle.Mark：唯一的中途写状态入口（2026-09-29 统一会话状态词表时新增）。
@@ -132,3 +133,64 @@ func TestNormalizeLegacyState(t *testing.T) {
 		t.Errorf("不认识的词原样返回，得到 %q", got)
 	}
 }
+
+/* Handle.Touch：只续期，不改状态（2026-10-22 报障「团队模式子任务还在跑 主会话
+ * 就说结束了」的真因之一）。
+ *
+ * 为什么 Mark 顶不上：Mark 在新旧状态相同时**直接 return、一次盘都不写**。流式路径
+ * 里每条事件都喊一次 Mark(running)，看起来像在续期，实际 updated_at 从第一条事件
+ * 起就冻住了 —— 团队模式计划 + 子任务几分钟不动，网关尾随连接据此判终态，
+ * 画面提前落「这一轮已结束」。 */
+func TestHandleTouchRefreshesUpdatedAt(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	h, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	runID := h.RunID()
+
+	// Mark 同值不写盘：这是 Touch 存在的理由，钉住它免得日后被「顺手优化」掉
+	before, _ := readRecord(h.path)
+	h.Mark(StateRunning)
+	after, _ := readRecord(h.path)
+	if !after.UpdatedAt.Equal(before.UpdatedAt) {
+		t.Errorf("Mark 同值不该写盘：%v → %v", before.UpdatedAt, after.UpdatedAt)
+	}
+
+	// Touch 必须真的把 updated_at 往前推
+	h.lastTouch = time.Time{} // 跳过节流
+	h.Touch(0)
+	rec, found, _ := Find(runID)
+	if !found {
+		t.Fatal("记录不见了")
+	}
+	if !rec.UpdatedAt.After(before.UpdatedAt) {
+		t.Errorf("Touch 没续期：%v → %v", before.UpdatedAt, rec.UpdatedAt)
+	}
+	if rec.State != StateRunning {
+		t.Errorf("Touch 不该改状态，得到 %q", rec.State)
+	}
+}
+
+func TestHandleTouchThrottlesAndRespectsTerminal(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	h.lastTouch = time.Time{}
+	h.Touch(time.Hour) // 第一次写
+	first, _ := readRecord(h.path)
+
+	h.Touch(time.Hour) // 节流窗口内：不写
+	second, _ := readRecord(h.path)
+	if !second.UpdatedAt.Equal(first.UpdatedAt) {
+		t.Errorf("节流窗口内不该写盘：%v → %v", first.UpdatedAt, second.UpdatedAt)
+	}
+
+	// 终态是结论，心跳不许把它续活
+	h.Finish("", StateDone)
+	h.lastTouch = time.Time{}
+	h.Touch(0)
+	final, _ := readRecord(h.path)
+	if final.State != StateDone {
+		t.Errorf("Touch 把终态改掉了：%q", final.State)
+	}
+}