magic-agent 1.0.3 → 1.0.49

package/internal/session/sessionlog.go

@@ -20,11 +20,14 @@ package session
 
 import (
 	"bufio"
+	"bytes"
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
+	"sync"
 )
 
 // DefaultLogDir 返回 ~/.magic-agent/sessions/（与 core CLI 用的目录一致）。
@@ -39,6 +42,73 @@ func DefaultLogDir() (string, error) {
 	return filepath.Join(home, ".magic-agent", "sessions"), nil
 }
 
+// logPath 一条 id 对应的日志文件路径（不含「文件在不在」的判断）。
+func logPath(dir, id string) string { return filepath.Join(dir, id+".jsonl") }
+
+// ResolveLogID 把「会话 id 或运行 id」翻成**该读哪个文件**（返回的是文件名里那一段）。
+//
+// 为什么需要这层翻译（2026-10-15）：日志文件按 **session_id** 命名（core 侧见
+// internal/cli/sessionlog.go）—— 但客户端手里的 id 在很多时候还只是 **run_id**：
+//   - 正在跑的会话，在引擎吐出 session_id 之前，登记表里只有 run_id；
+//   - 引擎整轮都不给 id 的形态（dsh 的 headless 回退轮），run_id 是它唯一的地址；
+//   - core 侧现在**一开跑就先按 <run_id>.jsonl 落盘**（拿到 id 才改名），于是
+//     这两个名字都可能命中同一个文件。
+//
+// 不翻译的后果是静默失败：点开「正在跑」的会话读到空历史，看起来像「这条会话没有内容」。
+//
+// 顺序：① 同名文件在 → 就用它（覆盖 session_id 与「先按 run_id 落盘」的中间态）；
+//
+//	② 否则查登记表，**两个方向都试**：登记表的 session_id / run_id 各自的文件在就认；
+//	③ 都不成立 → 原样返回（读出来就是空，与「没有历史」同义）。
+//
+// ⚠️ ② 必须双向（2026-10-18 修）：文件叫 `<run_id>.jsonl` 是**合法终态**，不是临时态 ——
+// 引擎整轮没吐 id 的形态一直存在（dsh 的 headless 回退轮、部分引擎不调 OnSessionID），
+// 而磁盘上已经躺着一批这么命名的历史文件。此时按 session_id 去读（列表页把 session_id
+// 当主键，客户端点开传的就是它）单向翻译救不了：文件名与 session_id 都对不上，`Find`
+// 查回来又是同一个 session_id，于是读到空 + `has_log=true` 这种最难看的状态
+// （列表说「有内容」、点开说「还没有事件」）。
+//
+// 写盘侧同时尽力把名字**统一成 session_id**（CLI 的事件级兜底 + 各引擎的 OnSessionID，
+// 见 internal/cli/ask.go 与 internal/cli/sessionlog.go），但读取端仍要兜住上面那种形态 ——
+// 「文件叫什么」不能成为客户端必须知道的事。
+//
+// ⚠️ 只在 dir 与登记表目录不一致时也安全：② 多一层「文件在不在」的确认，
+// 不会把别的目录的会话错认进来（测试常传临时 dir）。
+func ResolveLogID(dir, id string) string {
+	id = strings.TrimSpace(id)
+	if dir == "" || id == "" {
+		return id
+	}
+	if fileExists(logPath(dir, id)) {
+		return id
+	}
+	rec, found, err := Find(id)
+	if err == nil && found {
+		for _, cand := range []string{rec.SessionID, rec.RunID} {
+			c := strings.TrimSpace(cand)
+			if c != "" && c != id && fileExists(logPath(dir, c)) {
+				return c
+			}
+		}
+	}
+	return id
+}
+
+// HasSessionLog 这条 id（会话 id 或 run id）有没有**可回放**的事件日志：
+// 文件要在、且非空（空文件等于没有内容可看）。
+func HasSessionLog(dir, id string) bool {
+	if dir == "" || strings.TrimSpace(id) == "" {
+		return false
+	}
+	st, err := os.Stat(logPath(dir, ResolveLogID(dir, id)))
+	return err == nil && st.Size() > 0
+}
+
+func fileExists(p string) bool {
+	st, err := os.Stat(p)
+	return err == nil && !st.IsDir()
+}
+
 // SeqOf 从**已解析**的一条事件里取出 seq。
 //
 // 为什么要回调而不是要求 T 带字段：本包被 CLI（`sessionEvent` 结构体）与 plugin
@@ -72,15 +142,40 @@ func ReadSessionLog[T any](dir, sessionID string, parse func([]byte) (T, error))
 //	「客户端的游标是不是超前了」（after > maxSeq ⇒ 客户端状态比磁盘还新，
 //	只可能是日志被重置过、或游标来自另一个会话）。只统计过滤后的事件得不到这个信息。
 //
-// ⚠️ 仍然顺序读完整文件后过滤，没有按 seq 做**定位**（文件是 NDJSON、seq 靠解析才拿到，
+// ⚠️ 续读走进程内尾部游标（见 tailMark）：上一次读完整份文件时记下「maxSeq 之后
 //
-//	无法 seek）。代价是每次续读都要解析整个文件；收益是**网络只传增量**。
-//	本项目的会话规模下这个取舍是划算的（本地解析毫秒级，跨网传全量是百 KB 级）。
+//	的字节偏移」，之后 after == maxSeq 的请求直接 seek 到那里只读尾部。
+//	游标未命中（进程重启 / seq 不吻合 / 文件被截断）才退回全量重扫 —— 结果一致，
+//	只是慢。输出形状与语义不变。
 func ReadSessionLogAfter[T any](dir, sessionID string, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error)) ([]T, uint64, error) {
+	return readSessionLogAfter(dir, sessionID, after, seqOf, parse, false)
+}
+
+// ReadSessionLogLean 与 ReadSessionLog 同语义，但在**解码前**摘掉顶层 snapshot 字段。
+//
+// 为什么需要「解码前」：snapshot 是该 item 到此刻的累积整段，每条增量事件都带一份，
+// 长会话的存档因此二次方膨胀（实测一条会话 9.4 万条 thinking = 283MB 快照，整份
+// 日志 338MB）。先 `json.Unmarshal` 再删字段意味着这 283MB 仍要逐条分配 + 反转义，
+// 读一次 6~7s；而回放侧只用增量 `text` 自己拼，没有一个消费方读事件级 snapshot。
+// 字节级摘除（见 stripSnapshotField）不解析它的值，磁盘存档原样保留。
+//
+// ⚠️ 只影响「读」，输出字段集与先读后删完全一致（test 钉着）。
+func ReadSessionLogLean[T any](dir, sessionID string, parse func([]byte) (T, error)) ([]T, error) {
+	evs, _, err := readSessionLogAfter(dir, sessionID, 0, nil, parse, true)
+	return evs, err
+}
+
+// ReadSessionLogAfterLean 是 ReadSessionLogAfter 的 lean 版本（断线续读 + 摘 snapshot）。
+func ReadSessionLogAfterLean[T any](dir, sessionID string, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error)) ([]T, uint64, error) {
+	return readSessionLogAfter(dir, sessionID, after, seqOf, parse, true)
+}
+
+func readSessionLogAfter[T any](dir, sessionID string, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error), slim bool) ([]T, uint64, error) {
 	if dir == "" {
 		return nil, 0, fmt.Errorf("ReadSessionLog: dir 不能为空（调用方需用 DefaultLogDir() 解析）")
 	}
-	f, err := os.Open(filepath.Join(dir, sessionID+".jsonl"))
+	path := logPath(dir, sessionID)
+	f, err := os.Open(path)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil, 0, nil // 没历史 ≠ 错
@@ -88,14 +183,482 @@ func ReadSessionLogAfter[T any](dir, sessionID string, after uint64, seqOf SeqOf
 		return nil, 0, err
 	}
 	defer f.Close()
-	return readNDJSON(f, after, seqOf, parse)
+
+	// 快路径：这个文件上次刚好读到 after 这条，直接从当时的偏移续读尾部。
+	if seqOf != nil && after > 0 {
+		if evs, maxSeq, ok := readFromTailMark(f, path, after, seqOf, parse, slim); ok {
+			return evs, maxSeq, nil
+		}
+	}
+
+	evs, maxSeq, err := readNDJSON(f, after, seqOf, parse, slim)
+	if err != nil {
+		return evs, maxSeq, err
+	}
+	if seqOf != nil {
+		// 全量扫过一遍 ⇒ maxSeq 与「最后一条完整行」的偏移是权威的，记下来给下次续读。
+		if st, serr := f.Stat(); serr == nil {
+			storeTailMark(path, maxSeq, completeLogEnd(f, st.Size()))
+		}
+	}
+	return evs, maxSeq, nil
+}
+
+// ReadSessionLogBefore 反向读「从文件尾跳过 skip 条之后的一页」事件（**向上翻历史**用）。
+//
+// 返回 (事件, 下一页游标, 是否还有更早, error)；事件按文件物理顺序（旧 → 新）排列。
+// skip = 0 等价于「从文件尾开始」，即离现在最近的一页。
+//
+// 为什么反向读：长会话日志几百 MB，全量扫一遍要数秒，而客户端一次只要一页。
+// 从 completeLogEnd 定起点按块倒读，攒够 limit 条就停 —— 代价与本页字节数成正比，
+// 与会话总长无关。跨块的半行用 pending 拼回去（同一行只会被解析一次）。
+//
+// ⚠️ 游标是**跳过条数**而不是 seq（2026-10-20 修正）：同一会话每次续跑都是新进程，
+// 旧版 writer 的 seq 每轮从 1 重来（实测一份 15737 行的日志里有 4 处回落到 1，且都
+// 紧跟一行 user）。拿 seq 当全局游标（`seq < before`）会在 run 边界处把更早的历史
+// 整段滤掉 —— 客户端连翻几页后 firstSeq 撞到 1，入口消失，可还有上万条永远读不到。
+// 跳过条数只依赖行的物理顺序，与 seq 怎么编号无关。
+//
+// ⚠️ 每一条**非空行**都计入游标（含解析失败的行）：正向读的 `total` 也是这么数的，
+// 两边口径必须一致。因此下一页游标由本函数算出（= 页首那条之前有多少条非空行），
+// 不能简单用「本页条数」去加 —— 坏行会让两者不相等，越翻越偏。
+//
+// alignTo 非 nil 时做页头对齐：取页内**最早一条**满足它的位置作为页首，更早的几条
+// （通常是上一轮回复的尾巴）留给下一页补 —— 客户端按轮渲染，页头切在轮次中间会让
+// 思考/正文各半截。返回的游标已经扣掉被裁的部分，所以既不重复也不丢。
+//
+// ⚠️ 一页必须**至少含一个轮次起点**（2026-10-20 用户：「滚一下至少也要补一轮回话
+// 不是只补几个子过程」）：思考密集的一轮里 200 条事件可能全是思考碎片，页内没有
+// user ⇒ 无从对齐，前插后画布只多出几行子过程，看着像「滚了没反应」。所以凑够
+// limit 后若还没见到 alignTo 就继续往前读，直到见到为止（上限 maxTurnPage，防止
+// 一轮极长时把整份日志读进内存）。
+func ReadSessionLogBefore[T any](dir, sessionID string, skip uint64, limit int, alignTo func(T) bool, parse func([]byte) (T, error)) ([]T, uint64, bool, error) {
+	return readSessionLogBefore(dir, sessionID, skip, limit, alignTo, parse, false)
+}
+
+// ReadSessionLogBeforeLean 是 ReadSessionLogBefore 的 lean 版本（反向分页 + 摘 snapshot）。
+func ReadSessionLogBeforeLean[T any](dir, sessionID string, skip uint64, limit int, alignTo func(T) bool, parse func([]byte) (T, error)) ([]T, uint64, bool, error) {
+	return readSessionLogBefore(dir, sessionID, skip, limit, alignTo, parse, true)
+}
+
+func readSessionLogBefore[T any](dir, sessionID string, skip uint64, limit int, alignTo func(T) bool, parse func([]byte) (T, error), slim bool) ([]T, uint64, bool, error) {
+	if dir == "" {
+		return nil, 0, false, fmt.Errorf("ReadSessionLogBefore: dir 不能为空（调用方需用 DefaultLogDir() 解析）")
+	}
+	if limit <= 0 {
+		limit = 200
+	}
+	path := logPath(dir, sessionID)
+	f, err := os.Open(path)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, 0, false, nil // 没历史 ≠ 错
+		}
+		return nil, 0, false, err
+	}
+	defer f.Close()
+	st, err := f.Stat()
+	if err != nil {
+		return nil, 0, false, err
+	}
+	// 只倒读到最后一个换行之后：末尾没写完的半行不能算「更早的历史」。
+	end := completeLogEnd(f, st.Size())
+	if end <= 0 {
+		return nil, 0, false, nil
+	}
+
+	const chunk = 512 * 1024
+	var rev []T       // 倒序收集（新 → 旧），最后反转成升序
+	var dist []uint64 // 与 rev 并行：该事件之前（更新一侧）已越过多少条非空行 = 它的绝对游标
+	pos := end
+	var pending []byte // 上一块开头那段「被切开的后半行」，等更靠前的字节拼回来
+	var seen uint64    // 从末尾起已经越过的非空行数（= 客户端已画/已丢的条数）
+	more := false
+	// 页上限：凑够一个轮次起点后立刻停；某一轮长到 25 页还没起点（极端）时按这个上限收手，
+	// 宁可多给几页子过程，也不把一份几十万条的日志整个读进内存。
+	maxTurnPage := limit * 25
+	sawStart := false
+	for pos > 0 && !more {
+		start := pos - chunk
+		if start < 0 {
+			start = 0
+		}
+		buf := make([]byte, pos-start)
+		n, rerr := f.ReadAt(buf, start)
+		if rerr != nil && !errors.Is(rerr, io.EOF) {
+			return nil, 0, false, rerr
+		}
+		buf = append(buf[:n], pending...)
+		lines := bytes.Split(buf, []byte{'\n'})
+		var carry []byte
+		if start > 0 {
+			// 第一段从块中间切开的半行：它缺的是**前半段**（在更靠前的块里），本块解析不了。
+			carry = append([]byte(nil), lines[0]...)
+			lines = lines[1:]
+		}
+		if m := len(lines); m > 0 && len(lines[m-1]) == 0 {
+			lines = lines[:m-1] // end 恰好落在 \n 之后，块尾的空段不是事件
+		}
+		for i := len(lines) - 1; i >= 0; i-- {
+			line := lines[i]
+			if m := len(line); m > 0 && line[m-1] == '\r' {
+				line = line[:m-1]
+			}
+			if len(line) == 0 {
+				continue
+			}
+			// 跳过客户端已经画在屏幕上的那一段（含解析失败的行 —— 与正向 total 同口径）。
+			if seen < skip {
+				seen++
+				continue
+			}
+			d := seen
+			seen++
+			if slim {
+				line = stripSnapshotField(line)
+			}
+			v, perr := parse(line)
+			if perr != nil {
+				fmt.Fprintf(os.Stderr, "magic-agent: 会话历史行解析失败：%v（跳过该行）\n", perr)
+				continue
+			}
+			rev = append(rev, v)
+			dist = append(dist, d)
+			if alignTo != nil && alignTo(v) {
+				sawStart = true
+			}
+			// 够一页了，且这页里已经有轮次起点（或已到上限）→ 停。
+			// 没有起点就继续往前读：否则这一页全是同一轮的思考碎片，前插后看不出变化。
+			if len(rev) >= limit && (alignTo == nil || sawStart || len(rev) >= maxTurnPage) {
+				// 还有更早：本块里还有没处理的（i > 0），或者前面还有块。
+				more = i > 0 || start > 0
+				break
+			}
+		}
+		pos = start
+		pending = carry
+	}
+
+	out := make([]T, len(rev))
+	distOut := make([]uint64, len(rev))
+	for i := range rev {
+		out[len(rev)-1-i] = rev[i]
+		distOut[len(rev)-1-i] = dist[i]
+	}
+	if len(out) == 0 {
+		// 窗口里一条都解析不出来（全是坏行）⇒ 没有更早可给的了，游标推到已消费的位置。
+		return out, skip + seen, false, nil
+	}
+	// 页头对齐：切到页内最早一条轮次起点，更早的几条由下一页补（游标已扣掉，不重不漏）。
+	keep := 0
+	if alignTo != nil {
+		for i := range out {
+			if alignTo(out[i]) {
+				keep = i
+				break
+			}
+		}
+	}
+	if keep > 0 {
+		out = out[keep:]
+		more = true
+	}
+	// 下一页游标 = 页首那条的绝对距离 + 1（跳过它自己）—— 不能拿「本页条数」相加：
+	// 坏行占位置但不返回，相加会越翻越偏、把同一条事件重复取回。
+	nextSkip := distOut[keep] + 1
+	return out, nextSkip, more, nil
+}
+
+// tailMark 记「某个日志文件已经完整消费到哪儿」：
+// seq 是已读到的最大 seq，offset 是**那一行之后**的文件偏移（下一次从这里续读）。
+//
+// 为什么要它（2026-10-20）：日志是纯追加的 NDJSON，但 seq 只能解析出来，无法 seek 定位。
+// 于是每个 `/events?after=N` 都从文件头重扫全文 —— 移动端每 3s 对每个运行中会话轮询
+// 一次，354MB 的会话单次 2~3.4s，还会和历史加载抢磁盘。用进程内游标记住「seq=N 之后
+// 的字节从哪开始」，续读就只碰尾部那几行（实测 2.6s → 1~3ms）。
+//
+// 只放在进程内存里（不落盘）：错失最多是退回全量重扫，没有正确性代价。
+type tailMark struct {
+	seq    uint64
+	offset int64
+}
+
+// tailMarkKeep 每个文件保留几个游标。
+//
+// 为什么不止一个：同一会话可能有多个客户端（PC / 移动端 / 另一个标签页）各自按自己的
+// 游标轮询，而它们的进度天然错开一两拍。只留最新一个的话，别人一推进游标，落后的客户端
+// 每次轮询都得全量重扫（又回到最慢的路径）。留最近几拍即可覆盖这种错位。
+const tailMarkKeep = 8
+
+// tailMarkSet 一个文件的游标集合（按 seq 降序，最多 tailMarkKeep 条）。
+type tailMarkSet struct {
+	mu    sync.Mutex
+	marks []tailMark
+}
+
+var tailMarks sync.Map // key: 日志文件路径；value: *tailMarkSet
+
+// readFromTailMark 尝试按游标续读；不可用（没有匹配的 seq / 文件变短 / seek 失败）返回 ok=false。
+//
+// 并发下多个请求可能同时命中同一个游标：谁都从同一偏移读、都只读完整行 —— 结果是
+// 重复返回，不会漏。游标更新见 storeTailMark。
+func readFromTailMark[T any](f *os.File, path string, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error), slim bool) ([]T, uint64, bool) {
+	m, ok := loadTailMark(path, after)
+	if !ok {
+		return nil, 0, false
+	}
+	st, err := f.Stat()
+	if err != nil || m.offset > st.Size() {
+		return nil, 0, false // 文件被截断 / 重置过 ⇒ 游标作废
+	}
+	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)
+	if err != nil {
+		return nil, 0, false
+	}
+	storeTailMark(path, maxSeq, consumed)
+	return evs, maxSeq, true
+}
+
+// loadTailMark 取 seq == after 的游标（offset <= 0 的占位不算）。
+func loadTailMark(path string, after uint64) (tailMark, bool) {
+	v, ok := tailMarks.Load(path)
+	if !ok {
+		return tailMark{}, false
+	}
+	set, ok := v.(*tailMarkSet)
+	if !ok {
+		return tailMark{}, false
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	for _, m := range set.marks {
+		if m.seq == after && m.offset > 0 {
+			return m, true
+		}
+	}
+	return tailMark{}, false
+}
+
+// storeTailMark 记一个游标；offset<=0（还没有完整行）或 seq==0 时不记。
+// 同一 seq 只留最新一条；超过 tailMarkKeep 条时丢最旧的（seq 最小的）。
+func storeTailMark(path string, seq uint64, offset int64) {
+	if seq == 0 || offset <= 0 {
+		return
+	}
+	v, _ := tailMarks.LoadOrStore(path, &tailMarkSet{})
+	set, ok := v.(*tailMarkSet)
+	if !ok {
+		set = &tailMarkSet{}
+		tailMarks.Store(path, set)
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+
+	next := make([]tailMark, 0, tailMarkKeep)
+	inserted := false
+	for _, m := range set.marks {
+		if m.seq == seq {
+			continue // 同一 seq 以新偏移为准
+		}
+		if !inserted && m.seq < seq {
+			next = append(next, tailMark{seq: seq, offset: offset})
+			inserted = true
+		}
+		if len(next) < tailMarkKeep {
+			next = append(next, m)
+		}
+	}
+	if !inserted && len(next) < tailMarkKeep {
+		next = append(next, tailMark{seq: seq, offset: offset})
+	}
+	set.marks = next
+}
+
+// completeLogEnd 返回 size 之前「最后一个换行符之后」的偏移（= 可安全消费的字节数）。
+// 末尾还没写完的半行不算：下次续读从那里重新读，等它落完换行再消费。
+// 找不到换行（整份文件就一行半）返回 0。
+func completeLogEnd(f *os.File, size int64) int64 {
+	if size <= 0 {
+		return 0
+	}
+	const chunk = 64 * 1024
+	buf := make([]byte, chunk)
+	for end := size; end > 0; {
+		start := end - chunk
+		if start < 0 {
+			start = 0
+		}
+		n, _ := f.ReadAt(buf[:end-start], start)
+		if n <= 0 {
+			return 0
+		}
+		if i := bytes.LastIndexByte(buf[:n], '\n'); i >= 0 {
+			return start + int64(i) + 1
+		}
+		end = start
+	}
+	return 0
+}
+
+// readNDJSONFrom 从 pos 起续读到尾，语义与 readNDJSON 相同（同样的过滤 / 坏行跳过 / slim），
+// 额外返回「已消费到的偏移」—— 只累加**带换行**的完整行，末尾半行留给下次。
+//
+// maxSeq 以 after 为起点：本函数看不到文件前半段，但调用方的前提是 mark.seq == after
+// ⇒ 前半段的最大 seq 就是 after。这样「没有新事件」时 maxSeq 仍等于 after，
+// `after > maxSeq` 不会把「已追平」误判成「游标超前」。
+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
+	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, maxSeq, pos, err
+		}
+		pos += int64(len(line))
+		line = line[:len(line)-1]
+		if n := len(line); n > 0 && line[n-1] == '\r' {
+			line = line[:n-1]
+		}
+		if len(line) == 0 {
+			continue
+		}
+		if slim {
+			line = stripSnapshotField(line)
+		}
+		v, err := parse(line)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "magic-agent: 会话历史行解析失败：%v（跳过该行）\n", err)
+			continue
+		}
+		s := seqOf(v)
+		if s > maxSeq {
+			maxSeq = s
+		}
+		if s <= after {
+			continue
+		}
+		out = append(out, v)
+	}
+}
+
+var snapshotKeyPat = []byte(`,"snapshot":`)
+
+// stripSnapshotField 从一行 NDJSON 里整段摘掉顶层 `"snapshot"` 字段（**不解析它的值**）。
+//
+// 做法：找到 `,"snapshot":` 这个字面量，跳过它的 JSON 值，把这段字节删掉。
+//   - 为什么可以按字面量找：JSON 字符串内部的引号一定是转义的（`\"`），所以
+//     `,"snapshot":` 这一串只可能出现在**字段名**位置，text 里出现同名字样不会误伤。
+//   - 为什么从前往后找（bytes.Index）：snapshot 值本身可能几十 KB，而键在 text 之后、
+//     值之前 —— 正向扫只经过很小的前缀，反向扫要穿过整个值。
+//   - 值之后仍有字段（如 error / attachments）时保留后半段；是最后一个字段时
+//     顺带去掉前面的逗号（否则 `{"a":1,}` 不是合法 JSON）。
+//
+// 解析失败（值没闭合等坏行）原样返回：后面 json.Unmarshal 会照常报错并按坏行跳过，
+// 不在这一层发明第二种错误。
+func stripSnapshotField(line []byte) []byte {
+	idx := bytes.Index(line, snapshotKeyPat)
+	if idx < 0 {
+		return line
+	}
+	keyStart := idx // 保留逗号之前的字节，逗号一起删
+	vs := idx + len(snapshotKeyPat)
+	for vs < len(line) && (line[vs] == ' ' || line[vs] == '\t') {
+		vs++
+	}
+	ve := skipJSONValue(line, vs)
+	if ve < 0 {
+		return line
+	}
+	out := make([]byte, 0, keyStart+len(line)-ve)
+	out = append(out, line[:keyStart]...)
+	out = append(out, line[ve:]...)
+	return out
+}
+
+// endOfJSONString 返回从 i（必为 `"`）开始的 JSON 字符串值的结束位置（开区间）；未闭合返回 -1。
+//
+// 为什么不用逐字节开关扫：snapshot 值动辄几百 KB，逐字节过分支实测只有 1.8GB/s；
+// bytes.IndexByte 是 SIMD 实现（10GB/s+），只对命中的引号数一下前面的连续反斜杠 ——
+// 偶数个 ⇒ 没被转义，就是字符串结尾。
+func endOfJSONString(b []byte, i int) int {
+	from := i + 1
+	for from < len(b) {
+		n := bytes.IndexByte(b[from:], '"')
+		if n < 0 {
+			return -1
+		}
+		q := from + n
+		bs := 0
+		for k := q - 1; k > i && b[k] == '\\'; k-- {
+			bs++
+		}
+		if bs%2 == 0 {
+			return q + 1
+		}
+		from = q + 1
+	}
+	return -1
+}
+
+// skipJSONValue 返回从 i 开始的那个 JSON 值**结束位置**（开区间）；坏值返回 -1。
+// 只做结构跳过（字符串转义、括号配对），不解释内容 —— 这正是省掉 283MB 反转义的关键。
+func skipJSONValue(b []byte, i int) int {
+	if i >= len(b) {
+		return -1
+	}
+	switch b[i] {
+	case '"':
+		return endOfJSONString(b, i)
+	case '[', '{':
+		depth := 0
+		inStr := false
+		for j := i; j < len(b); j++ {
+			c := b[j]
+			if inStr {
+				if c == '\\' {
+					j++
+				} else if c == '"' {
+					inStr = false
+				}
+				continue
+			}
+			switch c {
+			case '"':
+				inStr = true
+			case '[', '{':
+				depth++
+			case ']', '}':
+				depth--
+				if depth == 0 {
+					return j + 1
+				}
+			}
+		}
+		return -1
+	default: // 数字 / true / false / null
+		for j := i; j < len(b); j++ {
+			if b[j] == ',' || b[j] == '}' {
+				return j
+			}
+		}
+		return len(b)
+	}
 }
 
 // readNDJSON 流式读 NDJSON。空行 / 坏行跳过（warn 一次）。
 //
 // after / seqOf 都可选：seqOf 为 nil 时不按 seq 过滤（此时 after 无意义），
 // 返回的 maxSeq 也就恒为 0 —— 这两个参数是配套的，调用方别只给一半。
-func readNDJSON[T any](r io.Reader, after uint64, seqOf SeqOf[T], parse func([]byte) (T, error)) ([]T, uint64, error) {
+// 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
 	sc := bufio.NewScanner(r)
@@ -105,6 +668,9 @@ func readNDJSON[T any](r io.Reader, after uint64, seqOf SeqOf[T], parse func([]b
 		if len(line) == 0 {
 			continue
 		}
+		if slim {
+			line = stripSnapshotField(line)
+		}
 		v, err := parse(line)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "magic-agent: 会话历史行解析失败：%v（跳过该行）\n", err)