magic-agent 1.0.49 → 1.0.109

package/internal/session/session_mark_test.go

@@ -70,11 +70,50 @@ func TestHandleMarkDoesNotTouchTerminalState(t *testing.T) {
 func TestHandleMarkRejectsOtherStates(t *testing.T) {
 	t.Setenv(EnvDir, t.TempDir())
 	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
-	h.Mark(StateFailed) // 不在允许的一对里
+	h.Mark(StateFailed) // 不在允许的活状态里
 	h.Mark(StateDone)
 	h.Mark("")
 	if got := h.Record().State; got != StateRunning {
-		t.Errorf("Mark 不该把它改成 %q（只允许 running / waiting_approval）", got)
+		t.Errorf("Mark 不该把它改成 %q（只允许 running / waiting_approval / idle）", got)
+	}
+}
+
+/* idle 是 keep-alive 会话**轮次之间**的状态（2026-10-21）：本轮已结束、进程还在等 --append。
+ * 它必须能 running ↔ idle 来回切，且**落盘** —— 别的端（移动端跟进 / 串行门）读的就是磁盘。 */
+func TestHandleMarkIdleRoundTrip(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()
+
+	h.Mark(StateIdle) // 本轮结束
+	rec, found, _ := Find(runID)
+	if !found || rec.State != StateIdle {
+		t.Fatalf("落盘状态 = %q found=%v, want %q", rec.State, found, StateIdle)
+	}
+
+	h.Mark(StateRunning) // 追加进来的下一轮开始
+	if got := h.Record().State; got != StateRunning {
+		t.Errorf("下一轮开始后状态 = %q want %q", got, StateRunning)
+	}
+
+	h.Mark(StateWaitingApproval) // idle → 等审批同样允许（进程还在，停下来问用户）
+	if got := h.Record().State; got != StateWaitingApproval {
+		t.Errorf("idle → 等审批后状态 = %q", got)
+	}
+}
+
+// idle 只说明「这一轮没在跑」，进程仍在 —— 进程真的没了才归一成 gone。
+func TestNormalizeDeadCoversIdle(t *testing.T) {
+	dead := &Record{State: StateIdle, PID: 999999}
+	if !normalizeDead(dead) || dead.State != StateGone {
+		t.Errorf("idle + 死进程应归一成 gone，得到 %q", dead.State)
+	}
+	live := &Record{State: StateIdle, PID: os.Getpid()}
+	if normalizeDead(live) || live.State != StateIdle {
+		t.Errorf("idle + 活进程不该被改，得到 %q", live.State)
 	}
 }
 
@@ -84,7 +123,7 @@ func TestNormalizeLegacyState(t *testing.T) {
 	if got := normalizeState("stopped"); got != StateCancelled {
 		t.Errorf("normalizeState(stopped) = %q, want %q", got, StateCancelled)
 	}
-	for _, s := range []string{StateRunning, StateWaitingApproval, StateDone, StateFailed, StateCancelled, StateInterrupted, StateGone} {
+	for _, s := range []string{StateRunning, StateWaitingApproval, StateIdle, StateDone, StateFailed, StateCancelled, StateInterrupted, StateGone} {
 		if got := normalizeState(s); got != s {
 			t.Errorf("normalizeState(%q) 不该改它，得到 %q", s, got)
 		}

package/internal/session/session_test.go

@@ -10,6 +10,7 @@ package session
 import (
 	"encoding/json"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -193,6 +194,48 @@ func TestFinishKeepsStoppedState(t *testing.T) {
 	}
 }
 
+// TestBeginSupersedesAliveSibling 同一条会话再起一次时，**还活着**的上一次运行必须被停掉。
+//
+// 背景（2026-10-21，用户：「两边的回话状态不一致，一边结束了，一边还在显示运行中」）：
+// 两个进程同时 --resume 同一 session 时，两边各写各的 seq 到同一份日志（成对重号），
+// 增量读的另一端会漏掉终态；登记表里旧 run 又一直 running，Find 永远答「在跑」。
+func TestBeginSupersedesAliveSibling(t *testing.T) {
+	isolate(t)
+
+	// 用一个真实存活进程冒充「同会话的上一次运行」（supersedeSiblings 会按 pid 判活、下手）。
+	old := exec.Command("sleep", "30")
+	if err := old.Start(); err != nil {
+		t.Fatalf("起占位进程: %v", err)
+	}
+	waited := make(chan struct{})
+	go func() { _ = old.Wait(); close(waited) }()
+	t.Cleanup(func() { _ = old.Process.Kill() })
+
+	oldH, err := Begin(BeginOptions{Engine: "claude", SessionID: "sess-dup", PID: old.Process.Pid})
+	if err != nil {
+		t.Fatalf("Begin(old): %v", err)
+	}
+
+	// 同会话再起一次（self pid 用测试进程自己）：旧的那次必须被停掉。
+	if _, err := Begin(BeginOptions{Engine: "claude", SessionID: "sess-dup", PID: os.Getpid()}); err != nil {
+		t.Fatalf("Begin(new): %v", err)
+	}
+
+	select {
+	case <-waited:
+	case <-time.After(3 * time.Second):
+		t.Fatal("同会话的上一次运行没有被停掉")
+	}
+
+	rec, found, err := Find(oldH.RunID())
+	if err != nil || !found {
+		t.Fatalf("Find(old) = %+v, %v, %v", rec, found, err)
+	}
+	if rec.State != StateCancelled {
+		t.Fatalf("旧 run 应写成 %q（否则 Find 会一直答「在跑」），实得 %q", StateCancelled, rec.State)
+	}
+}
+
 // 登记表**不按时间清理**：老记录必须留着（2026-10-18，用户：「永远保留啊 没有24小时限制」）。
 // 只有读不出来的坏文件才清 —— 它永远读不出来，留着只是噪音。
 func TestListKeepsOldRecordsDropsBroken(t *testing.T) {

package/internal/session/sessionlog.go

@@ -128,7 +128,7 @@ func ReadSessionLog[T any](dir, sessionID string, parse func([]byte) (T, error))
 }
 
 // ReadSessionLogAfter 只读 seq > after 的事件（**断线续读**用）。
-// 返回 (事件, 文件里的最大 seq, error)。after = 0 等价于全量。
+// 返回 (事件, 文件**末尾**那条事件的 seq, error)。after = 0 等价于全量。
 //
 // 语义对齐 agents-anywhere 的 `GET /sessions/{id}/events?after=seq:N`：
 // 客户端报「我已经看到 seq=N」，服务端就从 N+1 开始给。
@@ -137,14 +137,21 @@ func ReadSessionLog[T any](dir, sessionID string, parse func([]byte) (T, error))
 //
 //	逻辑从「优化」变成「必需」—— 而续读的全部意义就是让客户端不必再关心去重。
 //
-// ⚠️ 返回的 maxSeq 覆盖**整个文件**（含被 after 滤掉的部分）：调用方要用它判断
+// ⚠️ 返回的 lastSeq 是**最后一条物理行**的 seq，不是全文件最大 seq（2026-10-21 修正）。
 //
-//	「客户端的游标是不是超前了」（after > maxSeq ⇒ 客户端状态比磁盘还新，
-//	只可能是日志被重置过、或游标来自另一个会话）。只统计过滤后的事件得不到这个信息。
+//	旧版取 max，而同一会话每次续跑都是新进程、writer 又会在「拿到 session_id 后把
+//	<run_id>.jsonl 合并进 <session_id>.jsonl」时把 seq 重排回 1 —— 于是文件里 seq
+//	不是单调递增的：实测一份 21753 行的日志有 17 处回落，全局 max=9506，而正在跑的
+//	这一轮只到 2367。客户端游标停在 9506（旧轮末尾），`--after 9506` 把新轮 1..2367
+//	全按 `s <= after` 滤掉 ⇒ 增量永远为空、画布永远「已追平」（用户实测报障：
+//	「这不还是没进度吗」）。
 //
-// ⚠️ 续读走进程内尾部游标（见 tailMark）：上一次读完整份文件时记下「maxSeq 之后
+//	改取末尾 seq 后，这种陈旧游标满足 after > lastSeq，调用方据此判 snapshotRequired
+//	重拉全量，游标随即落到新轮的真实位置 —— 自愈，不必改客户端。
 //
-//	的字节偏移」，之后 after == maxSeq 的请求直接 seek 到那里只读尾部。
+// ⚠️ 续读走进程内尾部游标（见 tailMark）：上一次读完整份文件时记下「结尾 seq 之后
+//
+//	的字节偏移」，之后 after == lastSeq 的请求直接 seek 到那里只读尾部。
 //	游标未命中（进程重启 / seq 不吻合 / 文件被截断）才退回全量重扫 —— 结果一致，
 //	只是慢。输出形状与语义不变。
 func ReadSessionLogAfter[T any](dir, sessionID string, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error)) ([]T, uint64, error) {
@@ -186,22 +193,26 @@ func readSessionLogAfter[T any](dir, sessionID string, after uint64, seqOf SeqOf
 
 	// 快路径：这个文件上次刚好读到 after 这条，直接从当时的偏移续读尾部。
 	if seqOf != nil && after > 0 {
-		if evs, maxSeq, ok := readFromTailMark(f, path, after, seqOf, parse, slim); ok {
-			return evs, maxSeq, nil
+		if evs, tailSeq, ok := readFromTailMark(f, path, after, seqOf, parse, slim); ok {
+			return evs, tailSeq, nil
 		}
 	}
 
-	evs, maxSeq, err := readNDJSON(f, after, seqOf, parse, slim)
+	// 快路径可能已经 seek 过（命中游标后读失败）：全量扫必须从文件头开始。
+	if _, err := f.Seek(0, io.SeekStart); err != nil {
+		return nil, 0, err
+	}
+	evs, tailSeq, err := readNDJSON(f, after, seqOf, parse, slim)
 	if err != nil {
-		return evs, maxSeq, err
+		return evs, tailSeq, err
 	}
 	if seqOf != nil {
-		// 全量扫过一遍 ⇒ maxSeq 与「最后一条完整行」的偏移是权威的，记下来给下次续读。
+		// 全量扫过一遍 ⇒ tailSeq 与「最后一条完整行」的偏移是权威的，记下来给下次续读。
 		if st, serr := f.Stat(); serr == nil {
-			storeTailMark(path, maxSeq, completeLogEnd(f, st.Size()))
+			storeTailMark(path, tailSeq, completeLogEnd(f, st.Size()))
 		}
 	}
-	return evs, maxSeq, nil
+	return evs, tailSeq, nil
 }
 
 // ReadSessionLogBefore 反向读「从文件尾跳过 skip 条之后的一页」事件（**向上翻历史**用）。
@@ -370,7 +381,7 @@ func readSessionLogBefore[T any](dir, sessionID string, skip uint64, limit int,
 }
 
 // tailMark 记「某个日志文件已经完整消费到哪儿」：
-// seq 是已读到的最大 seq，offset 是**那一行之后**的文件偏移（下一次从这里续读）。
+// seq 是**最后一条完整行**的 seq，offset 是**那一行之后**的文件偏移（下一次从这里续读）。
 //
 // 为什么要它（2026-10-20）：日志是纯追加的 NDJSON，但 seq 只能解析出来，无法 seek 定位。
 // 于是每个 `/events?after=N` 都从文件头重扫全文 —— 移动端每 3s 对每个运行中会话轮询
@@ -414,12 +425,12 @@ func readFromTailMark[T any](f *os.File, path string, after uint64, seqOf SeqOf[
 	if _, err := f.Seek(m.offset, io.SeekStart); err != nil {
 		return nil, 0, false
 	}
-	evs, maxSeq, consumed, err := readNDJSONFrom(f, m.offset, after, seqOf, parse, slim)
+	evs, tailSeq, consumed, err := readNDJSONFrom(f, m.offset, after, seqOf, parse, slim)
 	if err != nil {
 		return nil, 0, false
 	}
-	storeTailMark(path, maxSeq, consumed)
-	return evs, maxSeq, true
+	storeTailMark(path, tailSeq, consumed)
+	return evs, tailSeq, true
 }
 
 // loadTailMark 取 seq == after 的游标（offset <= 0 的占位不算）。
@@ -506,21 +517,22 @@ func completeLogEnd(f *os.File, size int64) int64 {
 // readNDJSONFrom 从 pos 起续读到尾，语义与 readNDJSON 相同（同样的过滤 / 坏行跳过 / slim），
 // 额外返回「已消费到的偏移」—— 只累加**带换行**的完整行，末尾半行留给下次。
 //
-// maxSeq 以 after 为起点：本函数看不到文件前半段，但调用方的前提是 mark.seq == after
-// ⇒ 前半段的最大 seq 就是 after。这样「没有新事件」时 maxSeq 仍等于 after，
-// `after > maxSeq` 不会把「已追平」误判成「游标超前」。
+// tailSeq 以 after 为起点：读不到新行时它就是 after，`after > tailSeq` 不会把
+// 「已追平」误判成「游标超前」。读到新行后取**最后一条**的 seq（不是最大）：日志里
+// 可能有一轮 seq 从 1 重来，max 会永远停在旧轮的高位，游标就再也追不上（见
+// ReadSessionLogAfter 的说明）。
 func readNDJSONFrom[T any](f *os.File, start int64, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error), slim bool) ([]T, uint64, int64, error) {
 	var out []T
-	maxSeq := after
+	tailSeq := after
 	pos := start
 	br := bufio.NewReaderSize(f, 256*1024)
 	for {
 		line, err := br.ReadBytes('\n')
 		if err != nil {
 			if errors.Is(err, io.EOF) {
-				return out, maxSeq, pos, nil // 末尾半行还没落完：不消费
+				return out, tailSeq, pos, nil // 末尾半行还没落完：不消费
 			}
-			return out, maxSeq, pos, err
+			return out, tailSeq, pos, err
 		}
 		pos += int64(len(line))
 		line = line[:len(line)-1]
@@ -535,14 +547,17 @@ func readNDJSONFrom[T any](f *os.File, start int64, after uint64, seqOf SeqOf[T]
 		}
 		v, err := parse(line)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "magic-agent: 会话历史行解析失败：%v（跳过该行）\n", err)
+			fmt.Fprintf(os.Stderr, "magic-agent: 会话历史行解析失败（跳过该行）：%v\n", err)
 			continue
 		}
 		s := seqOf(v)
-		if s > maxSeq {
-			maxSeq = s
-		}
+		tailSeq = s
 		if s <= after {
+			// 不比游标新 ⇒ 这是文件里更早的那一段（同一 seq 可能在续跑后重复出现）。
+			// 游标的真实位置在这行**之后**：之前攒下的候选全部作废，否则旧轮里
+			// seq 高于游标的事件会被当成增量反复重投（2026-10-21 实测：续跑回落
+			// 的日志会让画布每秒重复插入旧事件）。
+			out = out[:0]
 			continue
 		}
 		out = append(out, v)
@@ -656,11 +671,11 @@ func skipJSONValue(b []byte, i int) int {
 // readNDJSON 流式读 NDJSON。空行 / 坏行跳过（warn 一次）。
 //
 // after / seqOf 都可选：seqOf 为 nil 时不按 seq 过滤（此时 after 无意义），
-// 返回的 maxSeq 也就恒为 0 —— 这两个参数是配套的，调用方别只给一半。
+// 返回的 tailSeq 也就恒为 0 —— 这两个参数是配套的，调用方别只给一半。
 // slim 为真时先做 stripSnapshotField（见 ReadSessionLogLean）。
 func readNDJSON[T any](r io.Reader, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error), slim bool) ([]T, uint64, error) {
 	var out []T
-	var maxSeq uint64
+	var tailSeq uint64
 	sc := bufio.NewScanner(r)
 	sc.Buffer(make([]byte, 0, 64*1024), 16*1024*1024)
 	for sc.Scan() {
@@ -681,14 +696,15 @@ func readNDJSON[T any](r io.Reader, after uint64, seqOf SeqOf[T], parse func([]b
 			continue
 		}
 		s := seqOf(v)
-		// maxSeq 先更新、后过滤：它要反映整个文件，而不只是这一页。
-		if s > maxSeq {
-			maxSeq = s
-		}
+		// 取最后一条（不是最大）：seq 可能在续跑时从 1 重来，max 会永远停在旧轮高位。
+		tailSeq = s
 		if s <= after {
+			// 与 readNDJSONFrom 同一条规则：见到「不比游标新」的行，说明游标的
+			// 真实位置更靠后，之前攒下的候选不是增量，作废。
+			out = out[:0]
 			continue
 		}
 		out = append(out, v)
 	}
-	return out, maxSeq, sc.Err()
+	return out, tailSeq, sc.Err()
 }

package/internal/session/sessionlog_read_test.go

@@ -12,8 +12,8 @@ import (
 //
 //  1. after 是**排他**上界（不回 seq == after 那条）——写成 >= 会让客户端每次续读
 //     都重收一条，去重逻辑就被迫成为必需；
-//  2. 返回的 maxSeq 覆盖**整个文件**而不只是这一页 —— 它是「客户端游标是否超前」的
-//     唯一判据，只统计过滤后的事件就永远判不出超前；
+//  2. 返回的 lastSeq 是**文件末尾那条**的 seq（不是全文件最大）——续跑会让 seq 从 1
+//     重来，取 max 会停在旧轮高位，游标永远追不上（2026-10-21 修）；
 //  3. 文件不存在时不是错误（新会话没有历史是正常状态）。
 
 // seqEvent 测试用的事件类型：带 seq 与 text 两个字段。
@@ -69,17 +69,17 @@ func TestReadSessionLogAfterFiltersBySeq(t *testing.T) {
 	}
 }
 
-// TestReadSessionLogAfterMaxSeqCoversWholeFile 是这一组里最要紧的一条：
-// maxSeq 必须反映**整个文件**，不能只统计返回的那一页。
+// TestReadSessionLogAfterAheadReportsTail 钉住「游标超前」的判据：即使这一页是空的，
+// lastSeq 也必须是文件末尾那条的 seq。
 //
-// 为什么：调用方用 `after > maxSeq` 判「客户端游标超前了（日志被重置 / 游标来自
-// 别的会话）」，超时时得以全量重建。若 maxSeq 只统计过滤结果，after=99 这类超前
-// 情形会得到 maxSeq=0，判据恒为真 —— 客户端会被永久判成「超前」，每次进会话都
+// 为什么：调用方用 `after > lastSeq` 判「客户端游标超前了（日志被重建 / 游标来自
+// 别的会话 / 本文件 seq 曾回落）」，超前时得以全量重建。若 lastSeq 只统计过滤结果，
+// after=99 这类情形会得到 0，判据恒为真 —— 客户端会被永久判成「超前」，每次进会话都
 // 重拉全量，增量能力形同虚设。
-func TestReadSessionLogAfterMaxSeqCoversWholeFile(t *testing.T) {
+func TestReadSessionLogAfterAheadReportsTail(t *testing.T) {
 	dir := writeLog(t, "s", `{"seq":1,"text":"a"}`, `{"seq":7,"text":"b"}`)
 
-	// after 超前（99 > 7）：这一页是空的，但 maxSeq 仍须是 7。
+	// after 超前（99 > 7）：这一页是空的，但 lastSeq 仍须是 7（文件末尾）。
 	evs, maxSeq, err := ReadSessionLogAfter(dir, "s", 99, func(e seqEvent) uint64 { return e.Seq }, parseSeqEvent)
 	if err != nil {
 		t.Fatal(err)
@@ -88,10 +88,10 @@ func TestReadSessionLogAfterMaxSeqCoversWholeFile(t *testing.T) {
 		t.Fatalf("after=99 期望空页，实得 %+v", evs)
 	}
 	if maxSeq != 7 {
-		t.Fatalf("超前时 maxSeq 仍须覆盖整个文件（期望 7，实得 %d）", maxSeq)
+		t.Fatalf("超前时 lastSeq 仍须是文件末尾（期望 7，实得 %d）", maxSeq)
 	}
 	if !(99 > maxSeq) {
-		t.Fatalf("判据 `after > maxSeq` 应为 true（客户端超前），maxSeq=%d", maxSeq)
+		t.Fatalf("判据 `after > lastSeq` 应为 true（客户端超前），lastSeq=%d", maxSeq)
 	}
 
 	// 追平（after == maxSeq）：空页，且判据为 false（这是正常的「没有新事件」）。
@@ -107,6 +107,64 @@ func TestReadSessionLogAfterMaxSeqCoversWholeFile(t *testing.T) {
 	}
 }
 
+// TestReadSessionLogAfterSeqReset 钉住 2026-10-21 的现场：同一份日志里 seq 回落
+// （旧轮 1..9506，新一轮又从 1 数起）。
+//
+// 回落来源：`--session <id>` 续接时 writer 先按 <run_id>.jsonl 从 1 写，拿到 id 后
+// 把内容合并进 <session_id>.jsonl —— 文件末尾的 seq 比中段小。客户端游标停在旧轮
+// 末位 9506 时，旧实现（按全文件 max 判游标）永远认为「已追平」，画布不再刷新
+// （用户实测：「这不还是没进度吗」）。
+func TestReadSessionLogAfterSeqReset(t *testing.T) {
+	dir := writeLog(t, "s",
+		`{"seq":9505,"text":"old-a"}`,
+		`{"seq":9506,"text":"old-b"}`,
+		`{"seq":1,"text":"new-a"}`,
+		`{"seq":2,"text":"new-b"}`)
+	seqOf := func(e seqEvent) uint64 { return e.Seq }
+
+	// ① 新轮进行中（游标 = 新轮 1）：只回新轮 2，旧轮 9505/9506 不算增量
+	//    （它们物理上在游标那条之前，投出去就是重复画旧事件）。
+	evs, last, err := ReadSessionLogAfter(dir, "s", 1, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 1 || evs[0].Text != "new-b" {
+		t.Fatalf("after=1 期望 [new-b]，实得 %+v", evs)
+	}
+	if last != 2 {
+		t.Fatalf("lastSeq 期望 2，实得 %d", last)
+	}
+
+	// ② 陈旧游标停在旧轮末位（用户实测就是这个状态）：一页空 + lastSeq 落到新轮末位，
+	//    调用方据此判 snapshotRequired 重拉全量，游标自愈。
+	evs, last, err = ReadSessionLogAfter(dir, "s", 9506, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 0 {
+		t.Fatalf("after=9506 期望空页，实得 %+v", evs)
+	}
+	if last != 2 {
+		t.Fatalf("lastSeq 期望新轮末位 2，实得 %d", last)
+	}
+	if !(9506 > last) {
+		t.Fatalf("陈旧游标须判成超前（snapshotRequired），lastSeq=%d", last)
+	}
+
+	// ③ 全量重读后游标 = 末位 2：不能再把旧轮 9505/9506 当增量重投（否则每个轮询
+	//    周期都往画布插一条旧事件）。
+	evs, last, err = ReadSessionLogAfter(dir, "s", 2, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 0 {
+		t.Fatalf("after=2（已追平）期望空页，实得 %+v", evs)
+	}
+	if last != 2 {
+		t.Fatalf("lastSeq 期望 2，实得 %d", last)
+	}
+}
+
 // TestReadSessionLogAfterMissingFile 没历史不是错（新会话 / 从未落盘）。
 func TestReadSessionLogAfterMissingFile(t *testing.T) {
 	dir := t.TempDir()

package/internal/session/status.go

@@ -0,0 +1,205 @@
+// status.go - 会话**级**状态：一张按会话存的覆盖表，客户端只读。
+//
+// 为什么需要（2026-10-21 用户：「会话状态搞一个字段 跟会话标题一样存起来 更新这个字段来统一」）：
+// 登记表是 **run 级**的 —— 一条会话每轮一个文件，各自记自己的 state。客户端拿到的行取决于
+// 「它挑中了哪一轮」：PC 按事件流已经显示「已完成」，移动端读到的却是上一轮的 running，
+// 于是同一会话在两端状态不一致，移动端的串行门（同空间有 running 就排队）还会一直排着。
+//
+// 这里把状态收成**一个会话一份**，与标题同一套做法：core 在写登记表时顺手更新，
+// 客户端只读一个字段，不再各自推算。存的是「这条会话最后一次已知状态」，不是「某一轮」。
+//
+// 存储：~/.magic-agent/session-status.json（与 session-titles.json 同目录），形状：
+//
+//	{ "<session_id>": {"state":"running","run_id":"run-…","run_started":"…","updated_at":"…"} }
+//
+// ⚠️ 键优先用 session_id（引擎给了才用），没给时退回 run_id；拿到 session_id 后把 run 键
+// 迁过去并删掉旧键 —— 留着两把键，按不同 id 读就会拿到两个状态（与标题同一个坑）。
+package session
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	statusMu     sync.Mutex
+	statusCache  map[string]StatusEntry
+	statusLoaded bool
+	// statusCachePath 缓存对应的表路径。生产里 EnvDir 不会中途变，但测试会反复换目录 ——
+	// 只认「同一张表」的缓存，换目录自动失效，用例之间不会互相串状态。
+	statusCachePath string
+)
+
+// StatusEntry 一条会话的当前状态（表里的值）。
+type StatusEntry struct {
+	State string `json:"state"`
+	// RunID / RunStarted 写下这条状态的是哪一轮、那一轮的开始时间。
+	//
+	// 为什么必须带 RunStarted：状态表是**会话级**的，而写入方是**各轮的进程** ——
+	// 旧一轮收尾（Finish / Stop / 进程已不在 → gone）可能晚于新一轮开跑，
+	// 没有排序守卫的话，迟到的「done」会把新一轮的「running」盖掉，
+	// 界面就变成「明明在跑却显示已完成」。
+	RunID      string    `json:"run_id,omitempty"`
+	RunStarted time.Time `json:"run_started"`
+	UpdatedAt  time.Time `json:"updated_at"`
+}
+
+// StatusStorePath 状态表路径（~/.magic-agent/session-status.json）。
+// 与标题表同目录同风格（见 TitleStorePath）：换实现不换位置。
+func StatusStorePath() (string, error) {
+	if p := strings.TrimSpace(os.Getenv(EnvDir)); p != "" {
+		return filepath.Join(filepath.Dir(p), "session-status.json"), nil
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return "", os.ErrNotExist
+	}
+	return filepath.Join(home, ".magic-agent", "session-status.json"), nil
+}
+
+// readStatusesLocked 从磁盘读整表（调用方须持 statusMu；文件不存在 = 空表）。
+func readStatusesLocked() map[string]StatusEntry {
+	out := map[string]StatusEntry{}
+	p, err := StatusStorePath()
+	if err != nil {
+		return out
+	}
+	if b, err := os.ReadFile(p); err == nil {
+		_ = json.Unmarshal(b, &out)
+	}
+	return out
+}
+
+func copyStatuses(m map[string]StatusEntry) map[string]StatusEntry {
+	out := make(map[string]StatusEntry, len(m))
+	for k, v := range m {
+		out[k] = v
+	}
+	return out
+}
+
+func saveStatusesLocked(m map[string]StatusEntry) error {
+	p, err := StatusStorePath()
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
+		return err
+	}
+	b, err := json.MarshalIndent(m, "", "  ")
+	if err != nil {
+		return err
+	}
+	if err := os.WriteFile(p, b, 0o600); err != nil {
+		return err
+	}
+	statusCache, statusLoaded, statusCachePath = m, true, p
+	return nil
+}
+
+// loadStatuses 读状态表（进程内缓存一份：列表页会逐行问状态，逐行读盘没必要）。
+// 写操作（setStatus / dropStatuses）后缓存随之更新。
+func loadStatuses() (map[string]StatusEntry, error) {
+	statusMu.Lock()
+	defer statusMu.Unlock()
+	p, err := StatusStorePath()
+	if err != nil {
+		return map[string]StatusEntry{}, nil
+	}
+	if statusLoaded && statusCachePath == p {
+		return copyStatuses(statusCache), nil
+	}
+	m := readStatusesLocked()
+	statusCache, statusLoaded, statusCachePath = m, true, p
+	return copyStatuses(m), nil
+}
+
+// StatusFor 取一条会话的状态（没有则空串）。
+func StatusFor(id string) string {
+	id = strings.TrimSpace(id)
+	if id == "" {
+		return ""
+	}
+	m, _ := loadStatuses()
+	return m[id].State
+}
+
+// StatusForAny 取一条会话的状态：**session_id 优先，其次 run_id**。
+//
+// 与 TitleForAny 同一个理由：引擎没吐 session_id 时键只能落在 run_id 上，
+// 而 run_id 每轮都换 —— 两个键都认，才谈得上「一条会话一个状态」。
+func StatusForAny(sessionID, runID string) string {
+	m, _ := loadStatuses()
+	if e, ok := m[strings.TrimSpace(sessionID)]; ok && e.State != "" {
+		return e.State
+	}
+	return m[strings.TrimSpace(runID)].State
+}
+
+// setStatus 把一条登记记录的状态写进会话级状态表（writeRecord 的收口点）。
+//
+// 两件事保证「统一」而不是「谁最后写谁算」：
+//
+//	① 排序守卫：只在写入方这一轮**不早于**表里那一轮时才覆盖。旧一轮收尾的 done/gone
+//	   迟到时直接丢弃，不会把新一轮的 running 盖掉；
+//	② 键归一：拿到 session_id 后写 session 键，并删掉本轮的 run 键（不留双键）。
+func setStatus(rec Record) {
+	if rec.State == "" {
+		return
+	}
+	sid := strings.TrimSpace(rec.SessionID)
+	rid := strings.TrimSpace(rec.RunID)
+	key := sid
+	if key == "" {
+		key = rid
+	}
+	if key == "" {
+		return
+	}
+	statusMu.Lock()
+	defer statusMu.Unlock()
+	m := readStatusesLocked()
+	cur, has := m[key]
+	started := rec.StartedAt
+	if started.IsZero() {
+		// 老记录没有开始时间：沿用表里已有的排序依据，别让零值把自己判成「最新一轮」。
+		started = cur.RunStarted
+	}
+	if has && !rec.StartedAt.IsZero() && cur.RunStarted.After(rec.StartedAt) {
+		return
+	}
+	if has && cur.State == rec.State && cur.RunID == rid && cur.RunStarted.Equal(started) {
+		return
+	}
+	m[key] = StatusEntry{State: rec.State, RunID: rid, RunStarted: started, UpdatedAt: time.Now()}
+	if sid != "" && rid != "" && rid != sid {
+		// 本轮的 run 键迁到 session 键上：留着它，按 run_id 读旧状态、按 session_id 读新状态。
+		if old, ok := m[rid]; ok && !old.RunStarted.After(rec.StartedAt) {
+			delete(m, rid)
+		}
+	}
+	_ = saveStatusesLocked(m)
+}
+
+// dropStatuses 清掉这些 id 上的状态（删除会话时用），返回清掉的条数。
+func dropStatuses(names map[string]bool) int {
+	statusMu.Lock()
+	defer statusMu.Unlock()
+	m := readStatusesLocked()
+	n := 0
+	for one := range names {
+		if _, ok := m[one]; ok {
+			delete(m, one)
+			n++
+		}
+	}
+	if n == 0 {
+		return 0
+	}
+	_ = saveStatusesLocked(m)
+	return n
+}