magic-agent 1.0.49 → 1.0.109

package/internal/cli/session.go

@@ -329,17 +329,41 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 		records = []session.Record{}
 	}
 	type row struct {
-		RunID      string `json:"run_id"`
-		SessionID  string `json:"session_id,omitempty"`
-		PID        int    `json:"pid"`
-		Engine     string `json:"engine"`
-		Model      string `json:"model,omitempty"`
-		Source     string `json:"source,omitempty"`
-		Client     string `json:"client,omitempty"`
-		State      string `json:"state"`
+		RunID     string `json:"run_id"`
+		SessionID string `json:"session_id,omitempty"`
+		PID       int    `json:"pid"`
+		Engine    string `json:"engine"`
+		Model     string `json:"model,omitempty"`
+		Source    string `json:"source,omitempty"`
+		Client    string `json:"client,omitempty"`
+		State     string `json:"state"`
+		// Status 这条会话的**统一状态**（session 级，见 internal/session/status.go）。
+		//
+		// 为什么与 state 并存（2026-10-21 用户：「会话状态搞一个字段 跟会话标题一样存起来
+		// 更新这个字段来统一」）：state 是**这一轮** run 的状态，同一会话多轮会给出不同值；
+		// 客户端各挑一行读，就会一端「已完成」、另一端还在「排队」。status 一条会话只一个值
+		// （core 在写登记表时同步更新），两端读它就必然一致。
+		// 老记录没有状态条目 → 回落 state，行为与改造前相同（只增字段，不升契约版本）。
+		Status     string `json:"status"`
 		Alive      bool   `json:"alive"`
 		Workspace  string `json:"workspace,omitempty"`
 		PromptHead string `json:"prompt_head,omitempty"`
+		// Mode 这条会话的运行模式：空 = 单引擎（默认）；"team" = 团队模式。
+		//
+		// 为什么列表要带它（2026-10-21）：团队模式下这条会话是**一组子任务**跑出来的，
+		// 列表上要有可分辨的痕迹，否则用户看到一条普通会话点进去发现是一堆委派卡。
+		// 只增字段，老客户端忽略即可。
+		Mode string `json:"mode,omitempty"`
+		// ParentRunID / ParentSessionID 父会话（团队主会话）指针；空 = 顶层会话。
+		//
+		// 团队拆出的子任务**是普通会话**（有自己的登记与日志），列表靠这两个字段
+		// 把它们缩进挂在主会话下面。两个都留：主会话可能在还没拿到 session_id 时
+		// 就拆出了子任务，读侧优先用 ParentSessionID，缺失再按 ParentRunID 认亲。
+		ParentRunID     string `json:"parent_run_id,omitempty"`
+		ParentSessionID string `json:"parent_session_id,omitempty"`
+		// Agents 团队模式下各类子任务实际派给了谁（按类别归并，同类只留一条）。
+		// 与 Mode 同批出现：`{kind,engine,model,count}`，客户端可据此画「谁在干活」。
+		Agents []session.AgentRef `json:"agents,omitempty"`
 		// Title 这条会话的**可展示标题**：优先标题表里的归纳结果（--summarize-title 写的），
 		// 没有就回落 prompt_head。
 		//
@@ -373,6 +397,13 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 		if title == "" {
 			title = r.PromptHead
 		}
+		/* 统一状态：一条会话一个值（各轮的行给出同一个），决定客户端画「进行中 / 已完成」。
+		   没有条目（改造前的老记录）才回落这一轮的 state。alive 也**按它算** ——
+		   否则一行里 status=idle、alive=true 自相矛盾，客户端又会分叉。 */
+		status := session.StatusForAny(r.SessionID, r.RunID)
+		if status == "" {
+			status = r.State
+		}
 		rows = append(rows, row{
 			RunID:           r.RunID,
 			SessionID:       r.SessionID,
@@ -382,9 +413,14 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 			Source:          r.Source,
 			Client:          r.Client,
 			State:           r.State,
-			Alive:           r.State == session.StateRunning,
+			Status:          status,
+			Alive:           status == session.StateRunning,
 			Workspace:       r.Workspace,
 			PromptHead:      r.PromptHead,
+			Mode:            r.Mode,
+			ParentRunID:     r.ParentRunID,
+			ParentSessionID: r.ParentSessionID,
+			Agents:          r.Agents,
 			Title:           title,
 			TitleSummarized: summarized,
 			StartedAt:       r.StartedAt.Format("2006-01-02 15:04:05"),
@@ -477,12 +513,12 @@ func runSessionLog(cmd *cobra.Command, opts *askOptions) error {
 
 	if flagChanged(cmd, "after") {
 		var evs []sessionEvent
-		var maxSeq uint64
+		var lastSeq uint64
 		var err error
 		if opts.logLean {
-			evs, maxSeq, err = ReadSessionLogAfterLean(dir, id, opts.logAfter)
+			evs, lastSeq, err = ReadSessionLogAfterLean(dir, id, opts.logAfter)
 		} else {
-			evs, maxSeq, err = ReadSessionLogAfter(dir, id, opts.logAfter)
+			evs, lastSeq, err = ReadSessionLogAfter(dir, id, opts.logAfter)
 		}
 		if err != nil {
 			return fmt.Errorf("--session-log %s: %w", id, err)
@@ -500,10 +536,11 @@ func runSessionLog(cmd *cobra.Command, opts *askOptions) error {
 			After   uint64         `json:"after"`
 			LastSeq uint64         `json:"lastSeq"`
 			// 调用方游标比磁盘还新 ⇒ 增量不可信，去拉全量。
+			// 「还新」= 大于**文件末尾那条**的 seq（不是全文件最大：续跑会让 seq 回落）。
 			// ⚠️ 判据是**严格大于**：after == lastSeq 是「已经追平」，那是正常的空增量。
 			SnapshotRequired bool `json:"snapshotRequired"`
 		}{Session: id, Events: evs, Count: len(evs), After: opts.logAfter,
-			LastSeq: maxSeq, SnapshotRequired: opts.logAfter > maxSeq})
+			LastSeq: lastSeq, SnapshotRequired: opts.logAfter > lastSeq})
 	}
 
 	var evs []sessionEvent
@@ -609,22 +646,24 @@ func runDeleteSession(cmd *cobra.Command, opts *askOptions) error {
 	}
 	if opts.output == "text" {
 		_, _ = fmt.Fprintf(cmd.OutOrStdout(),
-			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条）\n",
-			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved)
+			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条 / 状态 %d 条）\n",
+			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved, res.StatusesRemoved)
 		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"`
+		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:           "delete",
-		ID:             res.ID,
-		RecordsRemoved: res.RecordsRemoved,
-		LogsRemoved:    res.LogsRemoved,
-		TitlesRemoved:  res.TitlesRemoved,
+		Type:            "delete",
+		ID:              res.ID,
+		RecordsRemoved:  res.RecordsRemoved,
+		LogsRemoved:     res.LogsRemoved,
+		TitlesRemoved:   res.TitlesRemoved,
+		StatusesRemoved: res.StatusesRemoved,
 	}
 	return writeJSONLine(cmd.OutOrStdout(), out)
 }

package/internal/cli/sessionlog.go

@@ -50,11 +50,17 @@ var SessionLogDirOverride string
 
 // sessionLogDir 返回本会话日志的目录路径：
 //   - 显式 override（SessionLogDirOverride）优先；
+//   - 其次 $MAGIC_AGENT_SESSIONS（与 session.Dir() 同一口径：登记表换了目录，
+//     日志也必须跟着换 —— 否则 --sessions 在 A 目录、--session-log 读 B 目录，
+//     日志明明写着却「读不到历史」，这类分家最难查）；
 //   - 默认是 ~/.magic-agent/sessions（与 session 登记表同一目录）。
 func sessionLogDir() (string, error) {
 	if SessionLogDirOverride != "" {
 		return SessionLogDirOverride, nil
 	}
+	if p := strings.TrimSpace(os.Getenv(session.EnvDir)); p != "" {
+		return p, nil
+	}
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return "", fmt.Errorf("找不到家目录：%w", err)
@@ -86,9 +92,13 @@ type sessionEvent struct {
 	// agent_call / input_request / permission / tool_call），只有 tool_use 事件有，
 	// 与 SSE 流同源（见 agent/toolkind.go 与 events.go 的 toolKindOfEvent）。
 	// 有了它，历史回放和实时渲染才会画出同一种卡 —— 否则回放那侧只能按名字猜。
-	ToolKind  string            `json:"tool_kind,omitempty"`
-	SessionID string            `json:"session_id,omitempty"`
-	Ask       *agent.AskRequest `json:"ask,omitempty"`
+	ToolKind  string `json:"tool_kind,omitempty"`
+	SessionID string `json:"session_id,omitempty"`
+	// SubSessionID 子会话 id（2026-10-21，团队模式）：子任务自己的引擎会话 id，
+	// 绑定在主会话下面存档（列表里不单列）。落盘它是为了让**历史回放**也能在委派卡
+	// 上标出「这段活跑在哪个会话」—— 只展示，不参与日志文件名/锚点的判定。
+	SubSessionID string            `json:"sub_session_id,omitempty"`
+	Ask          *agent.AskRequest `json:"ask,omitempty"`
 	/* 状态收敛四元组（2026-10-02）。落盘它们是为了让**历史回放与实时渲染
 	   画出同一种东西**：回放侧不必自己猜「这条消息到哪算完」，
 	   按 (item_id, item_revision) 覆盖即可。缺了它们，历史里每条 text
@@ -96,6 +106,10 @@ type sessionEvent struct {
 	ItemID       string `json:"item_id,omitempty"`
 	ItemRevision uint64 `json:"item_revision,omitempty"`
 	Status       string `json:"status,omitempty"`
+	// Parent 父委派 id（2026-10-21，团队模式）：落盘它是为了让**历史回放**也把子任务
+	// 的事件挂回委派卡 —— 实时流与回放必须同构，否则「当时看到的」和「事后回看的」
+	// 会长成两张脸（这是本仓库反复踩过的那类问题）。
+	Parent string `json:"parent,omitempty"`
 	/* Snapshot 是「该 item 到此刻的累积整段」——**只读不写**（2026-10-20）。
 	   写盘时恒为空（见 appendLine）：每条增量都带一份 ⇒ 二次方膨胀
 	   （实测一条会话 1.8GB，95.6% 是它）。
@@ -131,8 +145,15 @@ type sessionWriter struct {
 	file     *os.File
 	w        *bufio.Writer
 	filePath string
-	fileName string        // 当前文件名（不含 .jsonl）；空 = 还没开文件
-	overflow atomic.Uint64 // 被 ring-buffer 丢弃的事件计数（诊断用）
+	fileName string // 当前文件名（不含 .jsonl）；空 = 还没开文件
+	// lastSize 上次 flush 之后**本进程期望的**文件字节数。
+	// 下一个事件写盘前拿 Stat 比一比：文件比这个数还大 ⇒ 有别的 writer 往同一份日志
+	// 追加过（本进程的增量都在 bufio 里，落盘后由 flush 同步这里），seq 必须重新接号。
+	// 见 resyncSeq（2026-10-21 用户报障：两端状态不一致 / 一端永远「生成中」）。
+	lastSize int64
+	// warnedConcurrent 并发追加的提示只打一次（每行都打会把 stderr 刷爆）。
+	warnedConcurrent bool
+	overflow         atomic.Uint64 // 被 ring-buffer 丢弃的事件计数（诊断用）
 	// poke 让主 goroutine 催一句「现在按最新名字把文件开出来 / 改名」，
 	// 不必等下一个事件 —— 否则「先 push 了 user 事件、随后才拿到 run_id」
 	// 或「id 刚到手就进入长时间静默」这两种情况下，文件会迟迟不出现。
@@ -313,6 +334,12 @@ func (sw *sessionWriter) flush() {
 	if sw.w != nil {
 		_ = sw.w.Flush()
 	}
+	// 记下我们期望的文件大小：下次 Stat 比它大 = 别人追加过（见 resyncSeq）。
+	if sw.file != nil {
+		if st, err := sw.file.Stat(); err == nil {
+			sw.lastSize = st.Size()
+		}
+	}
 }
 
 // write 是单条事件的落盘：先保证文件是最新名字的那个，再追加一行。
@@ -386,6 +413,7 @@ func (sw *sessionWriter) renameTo(name string) {
 		_ = sw.file.Close()
 	}
 	sw.file, sw.w, sw.filePath, sw.fileName = nil, nil, "", ""
+	sw.lastSize = 0
 	if _, err := os.Stat(newPath); err == nil {
 		appendFileInto(newPath, oldPath)
 	} else if err := os.Rename(oldPath, newPath); err != nil {
@@ -440,9 +468,14 @@ func (sw *sessionWriter) openFile(name string) error {
 	sw.file = f
 	sw.fileName = name
 	sw.w = bufio.NewWriterSize(f, 32*1024) // 32KB 缓冲；另有 1s 的定时 flush 兜底（见 flush）
-	if n := readMaxSeq(sw.filePath); n > 0 {
+	// 只升不降：换名字重开文件（run_id → session_id）时，本进程已经发出去的 seq
+	// 必须继续往上走；把计数器拨回文件里的旧值会让追加的事件与已写的重号。
+	if n := readMaxSeq(sw.filePath); n > sw.seq.Load() {
 		sw.seq.Store(n)
 	}
+	if st, err := f.Stat(); err == nil {
+		sw.lastSize = st.Size()
+	}
 	return nil
 }
 
@@ -519,6 +552,7 @@ func lastSeqIn(b []byte) uint64 {
 //
 // ⚠️ 字段本身保留（读旧档要认，见 sessionEventFromJSON）：只是不再**写**。
 func (sw *sessionWriter) appendLine(ev sessionEvent) {
+	sw.resyncSeq()
 	ev.Seq = sw.seq.Add(1)
 	if ev.At == "" {
 		ev.At = time.Now().UTC().Format(time.RFC3339Nano)
@@ -542,6 +576,41 @@ func (sw *sessionWriter) appendLine(ev sessionEvent) {
 	// 代价：断电最坏丢一小批；流路径完全不受影响。disk 也减少 90%+ 的 fsync。
 }
 
+// resyncSeq 在**别的 writer** 往同一份日志追加过时，把 seq 重新接到文件末尾。
+//
+// 背景（2026-10-21，用户：「两边的回话状态不一致，一边结束了，一边还在显示运行中」）：
+// 同一会话被两个进程同时 `--resume` 时，两边各有一个 sessionWriter，都在 openFile
+// 时读一次 max seq 然后并行 Add —— 文件里出现成对重号的 seq（实测一条 9506 条事件的
+// 日志里 4589 个重号）。读侧按 `--after seq` 增量续读，另一条 lane 之后写的事件全都
+// `seq <= after` 被滤掉：一端读到 turn_end 显示「已完成」，另一端永远等不到终态。
+//
+// 判据：文件比我们上次 flush 后期望的 size 还大 ⇒ 有人插队了。本进程自己的增量都
+// 在 bufio 里，落盘后由 flush 同步 lastSize；bufio 满溢自动写盘时读到的 max seq
+// 也不会超过 sw.seq，所以不会误报。
+//
+// 代价是每条事件一次 Stat（微秒级）。换来的是「重号」降级成「跳号」—— 跳号读侧
+// 天然容忍（`seq > after` 过滤），重号则静默丢事件。
+func (sw *sessionWriter) resyncSeq() {
+	if sw.file == nil {
+		return
+	}
+	st, err := sw.file.Stat()
+	if err != nil {
+		return
+	}
+	if st.Size() <= sw.lastSize {
+		return
+	}
+	if n := readMaxSeq(sw.filePath); n > sw.seq.Load() {
+		sw.seq.Store(n)
+		if !sw.warnedConcurrent {
+			sw.warnedConcurrent = true
+			fmt.Fprintf(os.Stderr, "magic-agent: 另一进程正在追加同一会话日志（%s），已跳号续写（两端进度可能不一致）\n", sw.filePath)
+		}
+	}
+	sw.lastSize = st.Size()
+}
+
 // sessionEventFromJSON 把 jsonl 的一行解析成 sessionEvent。
 // 与 session.ReadSessionLog 配对使用：CLI 知道自己的 schema，调用方把"怎么解析"
 // 当成回调传过去，避免 session 包反向依赖 cli。
@@ -585,7 +654,7 @@ func ReadSessionLog(dir, sessionID string) ([]sessionEvent, error) {
 	return session.ReadSessionLog(dir, sessionID, sessionEventFromJSON)
 }
 
-// ReadSessionLogAfter 增量读：只取 seq > after 的事件，并回磁盘上的最大 seq。
+// ReadSessionLogAfter 增量读：只取 seq > after 的事件，并回**文件末尾那条**的 seq。
 //
 // 存在的理由与全量读不同：断线重连 / 长会话续看时不必重传整段历史（差一个数量级）。
 // dir 传空 = 用默认历史目录（与 ReadSessionLog 同一口径）。

package/internal/cli/sessionlog_test.go

@@ -428,6 +428,64 @@ func TestSessionWriterSessionIDIsTerminalName(t *testing.T) {
 	}
 }
 
+// TestSessionWriterConcurrentWritersDoNotReuseSeq 两个 writer 并行往同一份日志追加时，
+// seq 必须**严格递增**（重号降级成跳号）。
+//
+// 背景（2026-10-21，用户：「两边的回话状态不一致，一边结束了，一边还在显示运行中」）：
+// 同一个 session 被两个进程同时 --resume，两边各自 openFile 读一次 max seq 后并行 Add，
+// 文件里出现成对重号。增量读（--after seq）会把后一条 lane 的事件全部滤掉 ——
+// 一端读到 turn_end 显示「已完成」，另一端永远等不到终态。见 resyncSeq。
+func TestSessionWriterConcurrentWritersDoNotReuseSeq(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "sess-race.jsonl")
+
+	a := newSessionWriter(dir, 1)
+	b := newSessionWriter(dir, 2)
+	a.setSessionID("sess-race")
+	b.setSessionID("sess-race")
+
+	// 等两边都把文件开出来（此时都读到空文件、seq 从 0 起）。
+	deadline := time.Now().Add(5 * time.Second)
+	for {
+		if _, err := os.Stat(path); err == nil {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatal("日志文件没被开出来")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	time.Sleep(100 * time.Millisecond) // 让后开的那条也把 openFile 走完
+
+	// A 先写两条并落盘（flush 后文件变大，B 的 lastSize 过期）。
+	a.push(sessionEvent{Kind: "text", Text: "a1"})
+	a.push(sessionEvent{Kind: "text", Text: "a2"})
+	a.close()
+	waitFileLines(t, path, 2)
+
+	// B 再写一条：必须重新接号，不能从 1 重来。
+	b.push(sessionEvent{Kind: "text", Text: "b1"})
+	b.close()
+
+	lines := readLines(t, path)
+	if len(lines) != 3 {
+		t.Fatalf("应有 3 行，实得 %d：%v", len(lines), lines)
+	}
+	var seqs []uint64
+	for i, ln := range lines {
+		var ev sessionEvent
+		if err := json.Unmarshal([]byte(ln), &ev); err != nil {
+			t.Fatalf("第 %d 行解析失败：%v", i, err)
+		}
+		seqs = append(seqs, ev.Seq)
+	}
+	for i := 1; i < len(seqs); i++ {
+		if seqs[i] <= seqs[i-1] {
+			t.Fatalf("seq 必须严格递增（重号会让增量读静默丢事件），实得 %v", seqs)
+		}
+	}
+}
+
 // drain 等 writer 的 in 通道全部写完。close 之后再等它把所有 pending 全 flush。
 func drain(t *testing.T, sw *sessionWriter) {
 	t.Helper()