magic-agent 1.0.3 → 1.0.49

package/internal/cli/sessionlog_test.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -217,6 +218,216 @@ func TestSessionWriterRealisticStream(t *testing.T) {
 	}
 }
 
+/* ── 2026-10-15：日志不再等 session_id 才创建 ──
+   用户要求：「不等终点事件就应该创建会话落库，这样多个客户端马上就能看到正在跑的会话」。
+   此前日志要等引擎吐 session_id 才知道文件名 → 正在跑的会话读出来永远是空历史；
+   引擎整轮不给 id 时（dsh 的 headless 回退轮）更是收工就把内存 buffer 丢光。 */
+
+// TestSessionWriterStartsByRunIDThenRenames：先有 run_id 就先落盘（不等引擎的 id），
+// 拿到 session_id 后改名成终名，内容一条不丢、顺序不变。
+func TestSessionWriterStartsByRunIDThenRenames(t *testing.T) {
+	dir := t.TempDir()
+	sw := newSessionWriter(dir, 1)
+	defer sw.close()
+	sw.setRunID("run-abc")
+	sw.push(sessionEvent{Kind: "user", Text: "帮我改一下"})
+
+	// 引擎还没吐 id 的这段时间里，别的客户端就该读得到内容（1s 的定时 flush 兜底）。
+	waitFileLines(t, filepath.Join(dir, "run-abc.jsonl"), 1)
+
+	sw.setSessionID("sess-1")
+	sw.push(sessionEvent{Kind: "text", Text: "好"})
+	drain(t, sw)
+
+	if _, err := os.Stat(filepath.Join(dir, "run-abc.jsonl")); !os.IsNotExist(err) {
+		t.Errorf("改名后不该再留着 <run_id>.jsonl（err=%v）", err)
+	}
+	lines := readLines(t, filepath.Join(dir, "sess-1.jsonl"))
+	if len(lines) != 2 {
+		t.Fatalf("期望 2 行，实得 %d：%v", len(lines), lines)
+	}
+	var a, b sessionEvent
+	_ = json.Unmarshal([]byte(lines[0]), &a)
+	_ = json.Unmarshal([]byte(lines[1]), &b)
+	if a.Kind != "user" || b.Kind != "text" {
+		t.Fatalf("顺序错：%s / %s", a.Kind, b.Kind)
+	}
+}
+
+// TestSessionWriterKeepsLogWhenEngineNeverReportsID：引擎整轮不给 id 时，
+// 内容也必须留在 <run_id>.jsonl —— 此前这种会话收工时 buffer 被丢光，
+// --save-history 白开、一个字节都落不下来（静默失败）。
+func TestSessionWriterKeepsLogWhenEngineNeverReportsID(t *testing.T) {
+	dir := t.TempDir()
+	sw := newSessionWriter(dir, 1)
+	sw.setRunID("run-noid")
+	sw.push(sessionEvent{Kind: "user", Text: "跑一下"})
+	sw.push(sessionEvent{Kind: "text", Text: "好了"})
+	sw.push(sessionEvent{Kind: "turn_end", Text: "好了"})
+	drain(t, sw)
+
+	lines := readLines(t, filepath.Join(dir, "run-noid.jsonl"))
+	if len(lines) != 3 {
+		t.Fatalf("引擎不给 id 时也要落满 3 行，实得 %d：%v", len(lines), lines)
+	}
+}
+
+// TestSessionWriterMergesIntoExistingFinalName：终名文件已存在时**不能覆盖** ——
+// os.Rename 在 Unix 下会静默把已有历史删掉（续接 / 重跑同一会话会撞上）。
+func TestSessionWriterMergesIntoExistingFinalName(t *testing.T) {
+	dir := t.TempDir()
+	old := filepath.Join(dir, "sess-dup.jsonl")
+	if err := os.WriteFile(old, []byte("{\"seq\":1,\"kind\":\"text\",\"text\":\"旧\",\"session_id\":\"sess-dup\"}\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	sw := newSessionWriter(dir, 1)
+	defer sw.close()
+	sw.setRunID("run-dup")
+	sw.push(sessionEvent{Kind: "user", Text: "再跑一轮"})
+	sw.setSessionID("sess-dup")
+	sw.push(sessionEvent{Kind: "text", Text: "新"})
+	drain(t, sw)
+
+	if _, err := os.Stat(filepath.Join(dir, "run-dup.jsonl")); !os.IsNotExist(err) {
+		t.Errorf("合并后不该留着 <run_id>.jsonl（err=%v）", err)
+	}
+	lines := readLines(t, old)
+	if len(lines) != 3 {
+		t.Fatalf("旧 1 行 + 新 2 行 = 3 行，实得 %d：%v", len(lines), lines)
+	}
+	if !strings.Contains(lines[0], "旧") || !strings.Contains(lines[2], "新") {
+		t.Fatalf("合并顺序错：%v", lines)
+	}
+}
+
+// TestSessionWriterUsesFinalNameWhenIDKnownUpfront：续接（一开始就知道 session_id）
+// 直接用终名，不产生 <run_id>.jsonl。
+func TestSessionWriterUsesFinalNameWhenIDKnownUpfront(t *testing.T) {
+	dir := t.TempDir()
+	sw := newSessionWriter(dir, 1)
+	sw.setRunID("run-resume")
+	sw.setSessionID("sess-resume")
+	sw.push(sessionEvent{Kind: "text", Text: "接着聊"})
+	drain(t, sw)
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, e := range entries {
+		names = append(names, e.Name())
+	}
+	if len(names) != 1 || names[0] != "sess-resume.jsonl" {
+		t.Fatalf("只该有 sess-resume.jsonl，实得 %v", names)
+	}
+}
+
+// waitFileLines 等文件出现且行数达到 want（写盘是异步的；1s 定时 flush 兜底）。
+func waitFileLines(t *testing.T, path string, want int) {
+	t.Helper()
+	deadline := time.Now().Add(5 * time.Second)
+	for time.Now().Before(deadline) {
+		if lines := readLinesIfAny(path); len(lines) >= want {
+			return
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+	t.Fatalf("%s 等不到 %d 行（实得 %d）", path, want, len(readLinesIfAny(path)))
+}
+
+// readLinesIfAny 读文件行数；文件不在或为空时返回 nil（**不** Fatal）。
+func readLinesIfAny(path string) []string {
+	b, err := os.ReadFile(path)
+	if err != nil || len(b) == 0 {
+		return nil
+	}
+	return strings.Split(strings.TrimRight(string(b), "\n"), "\n")
+}
+
+// TestSessionWriterSeqContinuesAcrossTurns 同一个日志文件跨轮追加时，seq 必须**接着上一轮**。
+//
+// 老行为是每轮从 1 重来（seq 只是「本进程内的行号」），于是同一个文件里出现多条 seq=1；
+// 客户端回放按 seq 去重 → 第二轮起的事件被当重复帧丢掉 → 界面上**只显示第一轮**
+// （用户 2026-10-16 报的「多轮对话只显示一轮」）。
+func TestSessionWriterSeqContinuesAcrossTurns(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "sess-seq.jsonl")
+
+	sw1 := newSessionWriter(dir, 1)
+	sw1.setSessionID("sess-seq")
+	sw1.push(sessionEvent{Kind: "user", Text: "第一轮"})
+	sw1.push(sessionEvent{Kind: "text", Text: "好"})
+	drain(t, sw1)
+
+	sw2 := newSessionWriter(dir, 2)
+	sw2.setSessionID("sess-seq")
+	sw2.push(sessionEvent{Kind: "user", Text: "第二轮"})
+	sw2.push(sessionEvent{Kind: "text", Text: "好的"})
+	drain(t, sw2)
+
+	lines := readLines(t, path)
+	if len(lines) != 4 {
+		t.Fatalf("两轮共 4 行，实得 %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)
+		}
+	}
+
+	// 反向验证：读回来的事件里两轮的 user 都在（回放不会只剩一轮）。
+	evs, err := ReadSessionLog(dir, "sess-seq")
+	if err != nil {
+		t.Fatalf("读历史失败：%v", err)
+	}
+	users := 0
+	for _, ev := range evs {
+		if ev.Kind == "user" {
+			users++
+		}
+	}
+	if users != 2 {
+		t.Fatalf("两轮对话应有 2 条 user，实得 %d", users)
+	}
+}
+
+// TestSessionWriterSessionIDIsTerminalName 日志文件名**统一成 session_id**。
+//
+// 一条会话的正常轨迹：先按 `<run_id>.jsonl` 开文件（引擎还没吐 id），id 到手后改名成
+// `<session_id>.jsonl` 终名。这是「客户端不必猜文件名」的前提（2026-10-18，用户：
+// 「runid 不能统一记成 sessionid 吗」）。
+//
+// ⚠️ 后半段是重点：id 到手之后，**不带 id 的事件（空串）不能把名字改回去** ——
+// 引擎只在开头几条事件带 id 是常态，回退一次就又变回 run_id 名了。
+func TestSessionWriterSessionIDIsTerminalName(t *testing.T) {
+	dir := t.TempDir()
+	sw := newSessionWriter(dir, 1)
+	sw.setRunID("run-x")
+	sw.push(sessionEvent{Kind: "text", Text: "a"}) // 还没有 id：先落在 run_id 名下
+	sw.setSessionID("sess-x")                      // id 到手 → 改名到终名
+	sw.push(sessionEvent{Kind: "text", Text: "b"})
+	sw.setSessionID("") // 后续事件不带 id（空串）→ 必须忽略
+	sw.push(sessionEvent{Kind: "text", Text: "c"})
+	drain(t, sw)
+
+	lines := readLines(t, filepath.Join(dir, "sess-x.jsonl"))
+	if len(lines) != 3 {
+		t.Fatalf("终名文件应有 3 行（pending 不丢、顺序不变），实得 %d：%v", len(lines), lines)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "run-x.jsonl")); !os.IsNotExist(err) {
+		t.Error("改名后不该再留下 run_id 名的文件（空 id 把它改回去了？）")
+	}
+}
+
 // drain 等 writer 的 in 通道全部写完。close 之后再等它把所有 pending 全 flush。
 func drain(t *testing.T, sw *sessionWriter) {
 	t.Helper()
@@ -260,3 +471,500 @@ func TestSessionWriterConcurrentSetIDAndPush(t *testing.T) {
 	wg.Wait()
 	sw.close()
 }
+
+// TestSessionLogBackwardCompatible 老 session log（没有收敛字段的）必须仍能读。
+//
+// 兼容性方向很重要：**新代码读旧数据**。字段全是 omitempty，所以旧 log 的
+// 每一行仍能解析成 sessionEvent，收敛字段读出来是零值。
+//
+// 反方向不成立且不需要成立：旧代码读新 log 时，多出来的键会被
+// encoding/json 忽略（没有 DisallowUnknownFields），也不会报错。
+func TestSessionLogBackwardCompatible(t *testing.T) {
+	dir := t.TempDir()
+	cli := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = cli }()
+	SessionLogDirOverride = dir
+
+	// 一份 2026-10-02 之前写出的真实形状：没有任何收敛字段。
+	legacy := `{"kind":"thinking","text":"我应该","seq":1}
+{"kind":"text","text":"收到","seq":2,"session_id":"sess-old"}
+{"kind":"turn_end","text":"收到","seq":3,"session_id":"sess-old"}
+`
+	path := filepath.Join(dir, "sess-old.jsonl")
+	if err := os.WriteFile(path, []byte(legacy), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	events, err := ReadSessionLog(dir, "sess-old")
+	if err != nil {
+		t.Fatalf("读旧 log 失败: %v", err)
+	}
+	if len(events) != 3 {
+		t.Fatalf("事件数 = %d，want 3", len(events))
+	}
+	for i, ev := range events {
+		if ev.ItemID != "" || ev.ItemRevision != 0 || ev.Status != "" || ev.Snapshot != "" {
+			t.Errorf("旧 log 的收敛字段应为零值，第 %d 条却是 %+v", i, ev)
+		}
+	}
+	// 旧数据的关键内容仍要读得出来。
+	if events[2].Kind != "turn_end" || events[2].Text != "收到" {
+		t.Errorf("旧 log 内容读取错误: %+v", events[2])
+	}
+}
+
+// TestStripSnapshots 守住 --session-log-lean 的口径：只清 snapshot，
+// 增量 text / item 收敛字段一律不动（回放全靠它们）。
+func TestStripSnapshots(t *testing.T) {
+	evs := []sessionEvent{
+		{Kind: "thinking", Text: "先", ItemID: "t1", ItemRevision: 1, Status: "running", Snapshot: "先"},
+		{Kind: "thinking", Text: "想", ItemID: "t1", ItemRevision: 2, Status: "running", Snapshot: "先想"},
+		{Kind: "text", Text: "收到", ItemID: "m1", ItemRevision: 1, Status: "final", Snapshot: "收到"},
+	}
+	stripSnapshots(evs)
+	for i, ev := range evs {
+		if ev.Snapshot != "" {
+			t.Errorf("第 %d 条 snapshot 未清掉: %q", i, ev.Snapshot)
+		}
+	}
+	if evs[1].Text != "想" || evs[1].ItemID != "t1" || evs[1].ItemRevision != 2 || evs[1].Status != "running" {
+		t.Errorf("增量/收敛字段被误伤: %+v", evs[1])
+	}
+}
+
+// TestSessionLogRoundTripsConvergenceFields 新写出的 log 必须带上收敛三元组
+// （item_id / item_revision / status），且**只靠增量 text** 就能复原出与实时流
+// 一致的收敛结果。
+//
+// ⚠️ 2026-10-20 起落盘**不写 snapshot**（见 appendLine）：它是「该 item 到此刻的
+// 累积整段」，每条增量都带一份 ⇒ 二次方膨胀（实测一条会话 1.8GB，95.6% 是它）。
+// 回放侧本来就是只用增量 text 自己拼（client-ui/shared/conv/09-stream-apply.js），
+// 所以「落盘数据足以复原收敛结果」这条要求改由增量累加兑现。
+func TestSessionLogRoundTripsConvergenceFields(t *testing.T) {
+	dir := t.TempDir()
+	cli := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = cli }()
+	SessionLogDirOverride = dir
+
+	sw, err := newSessionWriterAuto(sessionLogDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sw.setSessionID("sess-conv")
+	// 真实 Claude 一轮：思考两条 item 各两帧 + 正文一条 item + 终帧。
+	sw.push(sessionEvent{Kind: "thinking", Text: "先", ItemID: "claude_think_msg_x", ItemRevision: 1, Status: "running", Snapshot: "先"})
+	sw.push(sessionEvent{Kind: "thinking", Text: "想", ItemID: "claude_think_msg_x", ItemRevision: 2, Status: "running", Snapshot: "先想"})
+	sw.push(sessionEvent{Kind: "text", Text: "2", ItemID: "claude_msg_msg_x", ItemRevision: 1, Status: "running", Snapshot: "2"})
+	sw.push(sessionEvent{Kind: "turn_end", Text: "2", ItemID: "claude_msg_msg_x", ItemRevision: 2, Status: "final", Snapshot: "2"})
+	drain(t, sw)
+
+	events, err := ReadSessionLog(dir, "sess-conv")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(events) != 4 {
+		t.Fatalf("事件数 = %d，want 4", len(events))
+	}
+
+	// 落盘不得再带 snapshot（那是体积爆炸的根源）。
+	for i, ev := range events {
+		if ev.Snapshot != "" {
+			t.Errorf("第 %d 条仍带 snapshot（落盘不该再写它）: %q", i, ev.Snapshot)
+		}
+	}
+
+	// 按 item 覆盖式 upsert 回放：**增量 text 累加**出收敛结果
+	//（与回放侧 qaStreamApply 的 appendThinking/appendText 同一口径）。
+	// ⚠️ turn_end 的 text 是**权威全文**（覆盖，不是增量）—— 回放侧走 setResult，
+	//    这里也照它那样覆盖，否则会把终帧算成又一段增量。
+	final := map[string]string{}
+	for _, ev := range events {
+		if ev.ItemID == "" {
+			t.Fatalf("落盘缺 item_id: %+v", ev)
+		}
+		if ev.Kind == "turn_end" {
+			final[ev.ItemID] = ev.Text
+			continue
+		}
+		final[ev.ItemID] += ev.Text
+	}
+	if final["claude_msg_msg_x"] != "2" {
+		t.Errorf("正文 item 收敛结果 = %q，want \"2\"", final["claude_msg_msg_x"])
+	}
+	if final["claude_think_msg_x"] != "先想" {
+		t.Errorf("思考 item 收敛结果 = %q，want \"先想\"", final["claude_think_msg_x"])
+	}
+	// 两条 item 都在，且互不覆盖 —— 这正是拆 lane 的目的。
+	if len(final) != 2 {
+		t.Errorf("应收敛出 2 条 item，实得 %d：%v", len(final), final)
+	}
+}
+
+/* ── 2026-10-20：向上翻历史（--before / --limit） ──
+   用户要求：「默认加载最近的一轮用户和回复的对话即可」，向上滚动再按页补更早的。
+   长会话全量读一遍几百 MB 等不起，所以 core 从文件尾**反向分块**读，攒够一页就停。 */
+
+// writeSeqLog 造一份 seq 1..n 的日志；userSeqs 里的 seq 写成 kind=user。
+func writeSeqLog(t *testing.T, dir, id string, n int, userSeqs ...int) {
+	t.Helper()
+	isUser := map[int]bool{}
+	for _, s := range userSeqs {
+		isUser[s] = true
+	}
+	var b strings.Builder
+	for i := 1; i <= n; i++ {
+		kind := "text"
+		if isUser[i] {
+			kind = "user"
+		}
+		fmt.Fprintf(&b, "{\"seq\":%d,\"kind\":\"%s\",\"text\":\"t%d\",\"session_id\":\"%s\"}\n", i, kind, i, id)
+	}
+	if err := os.WriteFile(filepath.Join(dir, id+".jsonl"), []byte(b.String()), 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestReadSessionLogBeforePages 从尾往前翻页：页与页不重叠、不丢事件、升序输出。
+func TestReadSessionLogBeforePages(t *testing.T) {
+	dir := t.TempDir()
+	// 每页页首放一条 user：true 日志的每一轮都以 user 开头，而 readSessionLogBefore 现在
+	// 会「没见到轮次起点就继续往前读」，没有 user 的合成日志会被整份读成一页。
+	writeSeqLog(t, dir, "s", 50, 11, 21, 31, 41)
+
+	pos := uint64(0) // 0 = 从文件尾开始（跳过 0 条）
+	var pages [][]uint64
+	for page := 0; page < 10; page++ {
+		evs, next, more, err := ReadSessionLogBefore(dir, "s", pos, 10)
+		if err != nil {
+			t.Fatalf("第 %d 页失败：%v", page, err)
+		}
+		if len(evs) == 0 {
+			t.Fatalf("第 %d 页为空（more=%v next=%d）", page, more, next)
+		}
+		// 第 0 页是最新的 41..50，第 1 页 31..40 …… 每页内部升序。
+		hi := uint64(50 - page*10)
+		lo := hi - 9
+		if uint64(len(evs)) != 10 || evs[0].Seq != lo || evs[len(evs)-1].Seq != hi {
+			last := uint64(0)
+			if len(evs) > 0 {
+				last = evs[len(evs)-1].Seq
+			}
+			t.Fatalf("第 %d 页范围错：%d..%d（want %d..%d）", page, evs[0].Seq, last, lo, hi)
+		}
+		var seqs []uint64
+		for i, ev := range evs {
+			if i > 0 && ev.Seq <= evs[i-1].Seq {
+				t.Fatalf("页内必须升序：%v", []uint64{evs[i-1].Seq, ev.Seq})
+			}
+			seqs = append(seqs, ev.Seq)
+		}
+		pages = append(pages, seqs)
+		if !more {
+			break
+		}
+		// 下一页游标由 core 返回（含坏行/页头对齐的扣减），调用方不要自己加条数。
+		if next <= pos {
+			t.Fatalf("游标没前进：%d → %d（会死循环）", pos, next)
+		}
+		pos = next
+	}
+	// 页与页不重叠、不丢事件：页序反转（旧页在前）+ 页内升序，正好是 1..50。
+	var got []uint64
+	for i := len(pages) - 1; i >= 0; i-- {
+		got = append(got, pages[i]...)
+	}
+	if len(got) != 50 {
+		t.Fatalf("翻完应得 50 条，实得 %d：%v", len(got), got)
+	}
+	for i, s := range got {
+		if want := uint64(i + 1); s != want {
+			t.Fatalf("第 %d 条 = %d，want %d（重复或漏读）", i, s, want)
+		}
+	}
+}
+
+// TestReadSessionLogBeforeAcrossChunks 页面跨越 512KB 块边界时不能丢行/串行。
+func TestReadSessionLogBeforeAcrossChunks(t *testing.T) {
+	dir := t.TempDir()
+	pad := strings.Repeat("x", 2048)
+	var b strings.Builder
+	const n = 800 // ≈ 1.7MB，必然跨块
+	// 每 100 条一条 user（页首），否则「一页至少含一个轮次起点」会一路读回文件头。
+	isUser := map[int]bool{1: true}
+	for i := 101; i <= n; i += 100 {
+		isUser[i] = true
+	}
+	for i := 1; i <= n; i++ {
+		kind := "text"
+		if isUser[i] {
+			kind = "user"
+		}
+		fmt.Fprintf(&b, "{\"seq\":%d,\"kind\":\"%s\",\"text\":\"%03d-%s\",\"session_id\":\"big\"}\n", i, kind, i, pad)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "big.jsonl"), []byte(b.String()), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	evs, next, more, err := ReadSessionLogBefore(dir, "big", 0, 100)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 100 || !more {
+		t.Fatalf("首屏应 100 条且还有更早，实得 %d (more=%v)", len(evs), more)
+	}
+	if evs[0].Seq != uint64(n-99) || evs[len(evs)-1].Seq != n {
+		t.Fatalf("首屏范围错：first=%d last=%d", evs[0].Seq, evs[len(evs)-1].Seq)
+	}
+	// 跨块页：skip = core 返回的游标，起点落在第 2 块中间附近。
+	if next != 100 {
+		t.Fatalf("首屏游标应为 100，实得 %d", next)
+	}
+	evs2, _, _, err := ReadSessionLogBefore(dir, "big", next, 100)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs2) != 100 {
+		t.Fatalf("第二页应 100 条，实得 %d", len(evs2))
+	}
+	for i := 1; i < len(evs2); i++ {
+		if evs2[i].Seq != evs2[i-1].Seq+1 {
+			t.Fatalf("跨块页 seq 断裂：%d → %d", evs2[i-1].Seq, evs2[i].Seq)
+		}
+	}
+	if !strings.HasPrefix(evs2[len(evs2)-1].Text, fmt.Sprintf("%03d-", evs2[len(evs2)-1].Seq)) {
+		t.Fatalf("跨块行内容串了：seq=%d text=%q", evs2[len(evs2)-1].Seq, evs2[len(evs2)-1].Text[:16])
+	}
+}
+
+// TestReadSessionLogBeforeLean 反向读同样要在解码前摘掉 snapshot。
+func TestReadSessionLogBeforeLean(t *testing.T) {
+	dir := t.TempDir()
+	line := `{"seq":1,"kind":"thinking","text":"想","snapshot":"想了很久","session_id":"lean"}` + "\n"
+	if err := os.WriteFile(filepath.Join(dir, "lean.jsonl"), []byte(line), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	evs, _, _, err := ReadSessionLogBeforeLean(dir, "lean", 0, 10)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 1 || evs[0].Text != "想" || evs[0].Snapshot != "" {
+		t.Fatalf("lean 反向读结果错：%+v", evs)
+	}
+}
+
+// TestReadSessionLogBeforeAcrossSeqRestart 续跑后 seq 从 1 重新开始，翻页仍要跨得过去。
+//
+// 这是 2026-10-20 的真机缺陷：此前用 `seq < before` 当游标，翻到 seq=1 就再也读不到
+// 更早的 run（实测一份 15737 行的会话里 13298 条永远看不到，顶部却写着「还有 13298 条」）。
+// 改为按「从末尾跳过多少条」分页后，物理顺序是唯一依据，seq 怎么编号都无所谓。
+func TestReadSessionLogBeforeAcrossSeqRestart(t *testing.T) {
+	dir := t.TempDir()
+	var b strings.Builder
+	for i := 1; i <= 10; i++ {
+		kind := "text"
+		if i == 1 {
+			kind = "user"
+		}
+		fmt.Fprintf(&b, "{\"seq\":%d,\"kind\":\"%s\",\"text\":\"a%d\",\"session_id\":\"restart\"}\n", i, kind, i)
+	}
+	b.WriteString("{not json\n") // 坏行也计入跳过条数（与正向 total 同口径）
+	for i := 1; i <= 8; i++ {
+		kind := "text"
+		if i == 1 {
+			kind = "user"
+		}
+		fmt.Fprintf(&b, "{\"seq\":%d,\"kind\":\"%s\",\"text\":\"b%d\",\"session_id\":\"restart\"}\n", i, kind, i)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "restart.jsonl"), []byte(b.String()), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	var got []string
+	skip := uint64(0)
+	for page := 0; page < 10; page++ {
+		evs, next, more, err := ReadSessionLogBefore(dir, "restart", skip, 5)
+		if err != nil {
+			t.Fatalf("第 %d 页失败：%v", page, err)
+		}
+		var texts []string
+		for _, ev := range evs {
+			texts = append(texts, ev.Text)
+		}
+		got = append(texts, got...) // 页是新→旧读回的，倒着拼回升序
+		if !more {
+			break
+		}
+		if len(evs) == 0 {
+			t.Fatalf("第 %d 页为空但 more=true（skip=%d）", page, skip)
+		}
+		// 必须用 core 返回的游标：坏行占位置但不返回，拿本页条数相加会把
+		// 同一条事件重复取回（skip 从 5 变 9 时 a10 会被再读一次）。
+		if next <= skip {
+			t.Fatalf("第 %d 页游标没前进：%d → %d", page, skip, next)
+		}
+		skip = next
+	}
+
+	var want []string
+	for i := 1; i <= 10; i++ {
+		want = append(want, fmt.Sprintf("a%d", i))
+	}
+	for i := 1; i <= 8; i++ {
+		want = append(want, fmt.Sprintf("b%d", i))
+	}
+	if len(got) != len(want) {
+		t.Fatalf("翻完应得 %d 条，实得 %d：%v", len(want), len(got), got)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("第 %d 条 = %q，want %q（重复或漏读）：%v", i, got[i], want[i], got)
+		}
+	}
+}
+
+// TestSessionLogBeforeAlignsToUser 页头必须裁到该页最早一条 user：
+// 客户端按轮渲染，页头切在轮次中间会让思考/正文各半截。
+// 被裁掉的几条不算丢 —— more=true，且 nextBefore 已经退回到「被裁那几条之前」。
+func TestSessionLogBeforeAlignsToUser(t *testing.T) {
+	dir := t.TempDir()
+	cli := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = cli }()
+	SessionLogDirOverride = dir
+	// user 落在 25（上一页中间）与 41：本页 31..50 里最早一条 user 是 41。
+	writeSeqLog(t, dir, "s", 50, 1, 11, 21, 25, 41)
+
+	out, _, err := runAskCmd(t, "", "--session-log", "s", "--before", "0", "--limit", "20")
+	if err != nil {
+		t.Fatalf("--before 失败：%v", err)
+	}
+	var got struct {
+		Count      int            `json:"count"`
+		FirstSeq   uint64         `json:"firstSeq"`
+		NextBefore uint64         `json:"nextBefore"`
+		More       bool           `json:"more"`
+		Events     []sessionEvent `json:"events"`
+	}
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("输出不是 JSON：%v\n%s", err, out)
+	}
+	// 原始页是 31..50；最早 user 在 41 → 应裁成 41..50。
+	// 下一页要跳过 42..50（9 条）+ 41 自己 = 10 条，所以 nextBefore=10。
+	if got.Count != 10 || got.FirstSeq != 41 || !got.More {
+		t.Fatalf("页头对齐错：count=%d first=%d more=%v", got.Count, got.FirstSeq, got.More)
+	}
+	if got.NextBefore != 10 {
+		t.Fatalf("nextBefore 应退回被裁部分：%d（want 10）", got.NextBefore)
+	}
+	if got.Events[0].Kind != "user" || got.Events[0].Seq != 41 {
+		t.Fatalf("页首应是 user@41：%+v", got.Events[0])
+	}
+}
+
+// TestSessionLogBeforeKeepsWholeTurn 一页必须至少含一个轮次起点（user）。
+//
+// 2026-10-20 用户：「滚一下至少也要补一轮回话 不是只补几个子过程」。思考密集的一轮里
+// 一页 20 条可能全是同一轮的思考碎片 —— 页内没有 user，前插到画布上只多出几行子过程，
+// 看着像「滚了没反应」。所以凑够 limit 仍没见到 user 时要继续往前读，直到见到为止。
+func TestSessionLogBeforeKeepsWholeTurn(t *testing.T) {
+	dir := t.TempDir()
+	cli := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = cli }()
+	SessionLogDirOverride = dir
+	// 两轮：user@1 与 user@100；100 之后是 300 条思考碎片（模拟单轮被撑爆）。
+	writeSeqLog(t, dir, "s", 400, 1, 100)
+
+	out, _, err := runAskCmd(t, "", "--session-log", "s", "--before", "0", "--limit", "20")
+	if err != nil {
+		t.Fatalf("--before 失败：%v", err)
+	}
+	var got struct {
+		Count      int            `json:"count"`
+		FirstSeq   uint64         `json:"firstSeq"`
+		NextBefore uint64         `json:"nextBefore"`
+		More       bool           `json:"more"`
+		Events     []sessionEvent `json:"events"`
+	}
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("输出不是 JSON：%v\n%s", err, out)
+	}
+	// 起点应退到 user@100，把这一轮完整带回来（100..400），而不是只给 381..400。
+	if got.Count != 301 || got.FirstSeq != 100 {
+		t.Fatalf("应整轮返回 100..400（301 条），实得 %d 条 first=%d", got.Count, got.FirstSeq)
+	}
+	if got.Events[0].Kind != "user" || got.Events[0].Seq != 100 {
+		t.Fatalf("页首应是 user@100：%+v", got.Events[0])
+	}
+	if got.More != true {
+		t.Error("user@1 那一轮还没读（1..99），more 应为 true")
+	}
+}
+
+// TestSessionLogBeforeTurnCap 一轮长到超过上限时按 maxTurnPage 收手（不整份读进内存）。
+func TestSessionLogBeforeTurnCap(t *testing.T) {
+	dir := t.TempDir()
+	cli := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = cli }()
+	SessionLogDirOverride = dir
+	writeSeqLog(t, dir, "s", 400, 1) // 只有一条 user，后面 399 条思考
+
+	out, _, err := runAskCmd(t, "", "--session-log", "s", "--before", "0", "--limit", "2")
+	if err != nil {
+		t.Fatalf("--before 失败：%v", err)
+	}
+	var got struct {
+		Count      int    `json:"count"`
+		FirstSeq   uint64 `json:"firstSeq"`
+		NextBefore uint64 `json:"nextBefore"`
+		More       bool   `json:"more"`
+	}
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("输出不是 JSON：%v\n%s", err, out)
+	}
+	// limit=2 → 上限 50 条：应停在 351..400，不能一路读到 user@1。
+	if got.Count != 50 || got.FirstSeq != 351 || !got.More {
+		t.Fatalf("上限应收手在 50 条：count=%d first=%d more=%v", got.Count, got.FirstSeq, got.More)
+	}
+	if got.NextBefore != 50 {
+		t.Fatalf("nextBefore 应为 50，实得 %d", got.NextBefore)
+	}
+}
+
+// TestSessionLogBeforeArgs --before 与 --after 互斥；单给翻页参数要被拒绝（不静默忽略）。
+func TestSessionLogBeforeArgs(t *testing.T) {
+	dir := t.TempDir()
+	cli := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = cli }()
+	SessionLogDirOverride = dir
+	// user@4 是第二页的页首：没有它，「一页至少含一个轮次起点」会把 1..5 整份读成一页。
+	writeSeqLog(t, dir, "s", 5, 4)
+
+	if _, _, err := runAskCmd(t, "", "--session-log", "s", "--before", "5", "--after", "1"); err == nil {
+		t.Error("--before 与 --after 同时给应报错")
+	}
+	// --before 0 是合法的最新一页（跳过 0 条），不再当参数错。
+	out, _, err := runAskCmd(t, "", "--session-log", "s", "--before", "0", "--limit", "2")
+	if err != nil {
+		t.Fatalf("--before 0 应是最新一页：%v", err)
+	}
+	var got struct {
+		Count      int            `json:"count"`
+		NextBefore uint64         `json:"nextBefore"`
+		More       bool           `json:"more"`
+		Events     []sessionEvent `json:"events"`
+	}
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("输出不是 JSON：%v\n%s", err, out)
+	}
+	if got.Count != 2 || got.Events[0].Seq != 4 || got.Events[1].Seq != 5 || !got.More {
+		t.Fatalf("--before 0 应返回最后 2 条：count=%d more=%v events=%d", got.Count, got.More, len(got.Events))
+	}
+	if got.NextBefore != 2 {
+		t.Fatalf("nextBefore 应为 2，实得 %d", got.NextBefore)
+	}
+	if _, _, err := runAskCmd(t, "", "-p", "hi", "--before", "5"); err == nil {
+		t.Error("--before 不带 --session-log 应报错")
+	}
+	if _, _, err := runAskCmd(t, "", "-p", "hi", "--limit", "5"); err == nil {
+		t.Error("--limit 不带 --session-log 应报错")
+	}
+}