magic-agent 1.0.3 → 1.0.49

package/internal/client/session_events_test.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -184,3 +185,132 @@ func TestHandleSessionEvents(t *testing.T) {
 		}
 	})
 }
+
+// TestTruncRunes 钉住按字符（不是字节）截断，且不切坏多字节字符。
+func TestTruncRunes(t *testing.T) {
+	cases := []struct {
+		in   string
+		max  int
+		want string
+	}{
+		{"abc", 2, "ab"},
+		{"abc", 3, "abc"},
+		{"abc", 5, "abc"},
+		{"中文测试", 2, "中文"},
+		{"中文测试", 4, "中文测试"},
+		{"a中b", 2, "a中"},
+		{"😀😀", 1, "😀"},
+		{"abc", 0, "abc"},
+	}
+	for _, c := range cases {
+		if got := truncRunes(c.in, c.max); got != c.want {
+			t.Errorf("truncRunes(%q, %d) = %q，期望 %q", c.in, c.max, got, c.want)
+		}
+	}
+}
+
+// TestSessionLogLean 钉住 `?lean=1`（与 CLI 的 --session-log-lean 同一口径）：
+//
+//   - 不传：事件里的 `snapshot` 原样返回（旧行为，老客户端不受影响）
+//   - 传了：**键整个消失**（不是空串 —— CLI 侧 omitempty，两边要逐字段对齐），
+//     其余字段（seq / kind / text / item_id）一个不少
+//   - /messages 与 /events 两条接口都必须支持（移动端首屏走前者、续读走后者）
+//
+// 为什么要有这个开关：snapshot 是二次方膨胀的累积字段（实测一条会话 283MB），
+// 浏览器/手机端没人消费它，不裁就要解析整份 300MB+ JSON。
+func TestSessionLogLean(t *testing.T) {
+	home := t.TempDir()
+	dir := filepath.Join(home, ".magic-agent", "sessions")
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("HOME", home)
+	id := "sess-lean"
+	longOut := strings.Repeat("工", leanToolOutMax+500) // 超长工具输出（多字节，验证按 rune 截）
+	lines := []string{
+		`{"seq":1,"kind":"thinking","text":"想","snapshot":"想","item_id":"x_think_1"}`,
+		`{"seq":2,"kind":"thinking","text":"更","snapshot":"想更","item_id":"x_think_1"}`,
+		`{"seq":3,"kind":"text","text":"好","snapshot":"好","item_id":"x_msg_1"}`,
+		`{"seq":4,"kind":"tool_result","text":"` + longOut + `","name":"Bash"}`,
+	}
+	if err := os.WriteFile(filepath.Join(dir, id+".jsonl"), []byte(strings.Join(lines, "\n")+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	svc := newTestService(t, fakeCore(t, goodContract))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	read := func(t *testing.T, url string) []map[string]any {
+		t.Helper()
+		resp := doGET(t, url, true)
+		if resp.statusCode != http.StatusOK {
+			t.Fatalf("GET %s 期望 200，实得 %d", url, resp.statusCode)
+		}
+		var b struct {
+			Events []map[string]any `json:"events"`
+		}
+		if err := json.Unmarshal(resp.body, &b); err != nil {
+			t.Fatalf("解析响应失败：%v", err)
+		}
+		return b.Events
+	}
+
+	// 默认（不传 lean）：snapshot 原样保留 —— 只增参数，不传时行为不变。
+	full := read(t, srv.URL+"/desk/session/"+id+"/messages?token=tok")
+	if len(full) != 4 {
+		t.Fatalf("期望 4 条，实得 %d", len(full))
+	}
+	if full[1]["snapshot"] != "想更" {
+		t.Fatalf("不传 lean 时 snapshot 应原样返回，实得 %v", full[1]["snapshot"])
+	}
+	if got := full[3]["text"]; got != longOut {
+		t.Fatalf("不传 lean 时工具输出应原样返回，实得 %d 字符", len([]rune(fmt.Sprint(got))))
+	}
+
+	// /messages?lean=1：键消失，其余字段不动；相邻 thinking 并成一条；
+	// tool_result 截到 leanToolOutMax 个字符。
+	lean := read(t, srv.URL+"/desk/session/"+id+"/messages?lean=1&token=tok")
+	if len(lean) != 3 {
+		t.Fatalf("相邻 thinking 应并成一条（4 → 3），实得 %d", len(lean))
+	}
+	if got, want := fmt.Sprint(lean[0]["text"]), "想更"; got != want {
+		t.Fatalf("合并后的思考文本应为 %q，实得 %q", want, got)
+	}
+	if lean[0]["seq"] != float64(2) {
+		t.Fatalf("合并后应保留末条 seq（2），实得 %v", lean[0]["seq"])
+	}
+	for i, e := range lean {
+		if _, ok := e["snapshot"]; ok {
+			t.Fatalf("第 %d 条仍带 snapshot：%v", i, e)
+		}
+		if e["text"] == nil || e["seq"] == nil || e["kind"] == nil {
+			t.Fatalf("第 %d 条基础字段被误删：%v", i, e)
+		}
+		if i == 0 && e["item_id"] != "x_think_1" {
+			t.Fatalf("item_id 不该被裁掉：%v", e)
+		}
+		if i == 2 {
+			// 按 rune 截：len() 是字节数，中文会 ×3，必须数 rune 才对得上 12000。
+			if n := len([]rune(fmt.Sprint(e["text"]))); n != leanToolOutMax {
+				t.Fatalf("tool_result 应截到 %d 字符，实得 %d", leanToolOutMax, n)
+			}
+		}
+	}
+
+	// /events?after=1&lean=1：增量路径同样裁。
+	inc := read(t, srv.URL+"/desk/session/"+id+"/events?after=1&lean=1&token=tok")
+	if len(inc) != 3 {
+		t.Fatalf("after=1 期望 3 条，实得 %d", len(inc))
+	}
+	for i, e := range inc {
+		if _, ok := e["snapshot"]; ok {
+			t.Fatalf("增量第 %d 条仍带 snapshot：%v", i, e)
+		}
+		if i == 2 {
+			if n := len([]rune(fmt.Sprint(e["text"]))); n != leanToolOutMax {
+				t.Fatalf("增量里的 tool_result 也应截到 %d 字符，实得 %d", leanToolOutMax, n)
+			}
+		}
+	}
+}

package/internal/client/wsproxy.go

@@ -0,0 +1,113 @@
+package client
+
+import (
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+/* SOCKS5 over WebSocket。
+ *
+ * ── 为什么需要它 ──
+ * 移动端 VPN 的出口是一个 SOCKS5 服务，但 App 与桌面端之间隔着 Cloudflare 隧道，
+ * 而**Cloudflare 的 HTTP 隧道搬不了裸 TCP**（它只转 HTTP/WebSocket）——SOCKS5 连不上。
+ * 把 SOCKS5 的字节流整段塞进 WebSocket 之后，隧道就能把它带到公网了。
+ *
+ * ── 做法 ──
+ * 直接把这条 WebSocket 当成一个 net.Conn 交给现成的 serveSOCKS5：
+ * 于是 App 侧只要「把 hev 吐出来的 SOCKS5 字节原封不动转发到这个 WebSocket」，
+ * 桌面端无需为隧道另写一套协议 —— 两端传的就是同一串字节。
+ */
+
+const proxyWSPath = "/proxy-ws"
+
+var wsUpgrader = websocket.Upgrader{
+	ReadBufferSize:  32 * 1024,
+	WriteBufferSize: 32 * 1024,
+	// 由令牌把关，这里放宽 Origin：App 侧的 WebView/OkHttp 不会带站内 Origin。
+	CheckOrigin: func(r *http.Request) bool { return true },
+}
+
+// handleProxyWS 升级成 WebSocket，然后把它当作一条 SOCKS5 连接处理。
+func (s *Service) handleProxyWS(w http.ResponseWriter, r *http.Request) {
+	// 鉴权：与 /b/ 同口径 —— 查询令牌或 cookie。
+	if want := strings.TrimSpace(s.opts.Token); want != "" {
+		got := strings.TrimSpace(r.URL.Query().Get("token"))
+		if got == "" {
+			if c, err := r.Cookie(browseCookie); err == nil {
+				got = c.Value
+			}
+		}
+		if got != want {
+			http.Error(w, "缺少或错误的访问令牌", http.StatusUnauthorized)
+			return
+		}
+	}
+
+	c, err := wsUpgrader.Upgrade(w, r, nil)
+	if err != nil {
+		return // Upgrade 已经写过响应
+	}
+	defer func() {
+		// 发一个正常的关闭帧再关底层连接：直接 Close 会让对端收到 1006（异常关闭），
+		// 客户端会把它当成错误而不是正常结束。
+		_ = c.WriteControl(websocket.CloseMessage,
+			websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
+			time.Now().Add(time.Second))
+		_ = c.Close()
+	}()
+
+	if err := s.serveSOCKS5(newWSConn(c)); err != nil {
+		s.log.Printf("socks5(ws): %v", err)
+	}
+}
+
+// wsConn 把一条 WebSocket 伪装成 net.Conn：每个二进制帧就是一段字节。
+type wsConn struct {
+	ws *websocket.Conn
+
+	wmu sync.Mutex // gorilla 不允许并发写
+
+	rmu  sync.Mutex
+	rest []byte // 上一帧没读完的剩余字节
+}
+
+func newWSConn(c *websocket.Conn) *wsConn { return &wsConn{ws: c} }
+
+func (c *wsConn) Read(p []byte) (int, error) {
+	c.rmu.Lock()
+	defer c.rmu.Unlock()
+	for len(c.rest) == 0 {
+		_, data, err := c.ws.ReadMessage()
+		if err != nil {
+			return 0, err
+		}
+		if len(data) == 0 {
+			continue
+		}
+		c.rest = data
+	}
+	n := copy(p, c.rest)
+	c.rest = c.rest[n:]
+	return n, nil
+}
+
+func (c *wsConn) Write(p []byte) (int, error) {
+	c.wmu.Lock()
+	defer c.wmu.Unlock()
+	if err := c.ws.WriteMessage(websocket.BinaryMessage, p); err != nil {
+		return 0, err
+	}
+	return len(p), nil
+}
+
+func (c *wsConn) Close() error                       { return c.ws.Close() }
+func (c *wsConn) LocalAddr() net.Addr                { return c.ws.LocalAddr() }
+func (c *wsConn) RemoteAddr() net.Addr               { return c.ws.RemoteAddr() }
+func (c *wsConn) SetDeadline(t time.Time) error      { return c.ws.SetReadDeadline(t) }
+func (c *wsConn) SetReadDeadline(t time.Time) error  { return c.ws.SetReadDeadline(t) }
+func (c *wsConn) SetWriteDeadline(t time.Time) error { return c.ws.SetWriteDeadline(t) }

package/internal/client/wsproxy_test.go

@@ -0,0 +1,102 @@
+package client
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// TestProxyWS 端到端：连上 /proxy-ws，在 WebSocket 里跑完整 SOCKS5 握手并取回内容。
+// 这条通过的含意是：SOCKS5 真的能穿过「只能搬 HTTP/WS」的隧道（Cloudflare 那条路的可行性）。
+func TestProxyWS(t *testing.T) {
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = io.WriteString(w, "hello-over-websocket")
+	}))
+	defer upstream.Close()
+	uu, _ := url.Parse(upstream.URL)
+
+	s := &Service{log: testLogger(), opts: Options{Token: "sekret"}}
+	srv := httptest.NewServer(s.Handler())
+	defer srv.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(srv.URL, "http") + proxyWSPath + "?token=sekret"
+	ws, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
+	if err != nil {
+		t.Fatalf("连 WebSocket 失败：%v", err)
+	}
+	conn := newWSConn(ws)
+	defer conn.Close()
+
+	// 认证（RFC 1929）
+	if _, err := conn.Write([]byte{0x05, 0x01, 0x02}); err != nil {
+		t.Fatal(err)
+	}
+	sel := make([]byte, 2)
+	if _, err := io.ReadFull(conn, sel); err != nil || sel[1] != 0x02 {
+		t.Fatalf("协商失败：%v %v", sel, err)
+	}
+	auth := []byte{0x01, 5}
+	auth = append(auth, "magic"...)
+	auth = append(auth, 6)
+	auth = append(auth, "sekret"...)
+	if _, err := conn.Write(auth); err != nil {
+		t.Fatal(err)
+	}
+	ar := make([]byte, 2)
+	if _, err := io.ReadFull(conn, ar); err != nil || ar[1] != 0 {
+		t.Fatalf("认证失败：%v %v", ar, err)
+	}
+
+	// CONNECT 到上游 HTTP 服务
+	host, portStr, _ := net.SplitHostPort(uu.Host)
+	var port int
+	_, _ = fmt.Sscanf(portStr, "%d", &port)
+	req := []byte{0x05, 0x01, 0x00, 0x03, byte(len(host))}
+	req = append(req, host...)
+	p := make([]byte, 2)
+	binary.BigEndian.PutUint16(p, uint16(port))
+	req = append(req, p...)
+	if _, err := conn.Write(req); err != nil {
+		t.Fatal(err)
+	}
+	rep := make([]byte, 10)
+	if _, err := io.ReadFull(conn, rep); err != nil {
+		t.Fatal(err)
+	}
+	if rep[1] != 0x00 {
+		t.Fatalf("CONNECT 被拒：rep=%d", rep[1])
+	}
+
+	_ = conn.SetDeadline(time.Now().Add(10 * time.Second))
+	if _, err := io.WriteString(conn, "GET / HTTP/1.1\r\nHost: "+uu.Host+"\r\nConnection: close\r\n\r\n"); err != nil {
+		t.Fatal(err)
+	}
+	// 上游会关连接，读完即可；结尾的关闭错误是正常的（真实客户端也是这么处理的）。
+	body, _ := io.ReadAll(conn)
+	if !strings.Contains(string(body), "hello-over-websocket") {
+		t.Errorf("未取到上游内容，实际：%s", body)
+	}
+}
+
+// TestProxyWSRejectsBadToken 令牌不对必须拒。
+func TestProxyWSRejectsBadToken(t *testing.T) {
+	s := &Service{log: testLogger(), opts: Options{Token: "sekret"}}
+	srv := httptest.NewServer(s.Handler())
+	defer srv.Close()
+
+	wsURL := "ws" + strings.TrimPrefix(srv.URL, "http") + proxyWSPath + "?token=wrong"
+	if _, resp, err := websocket.DefaultDialer.Dial(wsURL, nil); err == nil {
+		t.Error("错误令牌应当被拒")
+	} else if resp != nil && resp.StatusCode != http.StatusUnauthorized {
+		t.Errorf("期望 401，实际 %d", resp.StatusCode)
+	}
+}

package/internal/session/delete.go

@@ -0,0 +1,151 @@
+// delete.go - 删除一条会话（登记记录 + 事件日志 + 标题覆盖）。
+//
+// 为什么要它（2026-10-19 用户：「从pc端删除的会话移动端还在显示」）：
+// 此前「删除」只发生在**客户端本地**（掌天瓶记一座 localStorage 墓碑、从自己的列表拿掉），
+// 而列表的权威来源是**登记表**：移动端 H5 走插件的 `/desk/sessions`、桌面端走
+// `--sessions`，读的都是这一份。于是 PC 上删掉的会话，在移动端照旧列着 ——
+// 「一端删了、另一端还在」正是没有把删除落在共享数据上的必然结果。
+//
+// 语义与插件的 `DELETE /desk/session/{id}`（internal/client/service.go）**逐字对齐**，
+// 两者现在共用这一份实现：
+//
+//	· 登记记录：按 session_id 或 run_id 命中的**每一条 run 记录**都删（一条会话每轮一条）；
+//	· 事件日志：`<session_id>.jsonl` 与 `<run_id>.jsonl` 两个名字都试 —— 引擎不回调
+//	  OnSessionID 时整轮都叫 `<run_id>.jsonl`（见 ResolveLogID 的说明），只删一个会
+//	  留下「列表里没了、磁盘上还占着」的孤儿日志；
+//	· 标题覆盖：一并清掉，避免「会话没了、标题表里还留着」。
+//
+// ⚠️ 这是**物理删除**（登记记录与日志文件都不在了），不是「本机隐藏」。
+//
+//	客户端要的是「删了就是删了、到哪台设备都看不到」，隐含代价是历史不可回放 ——
+//	所以客户端的删除入口必须把这件事说清楚（见 magic-test 的删除提示文案）。
+//
+// 幂等：id 不认识、文件本来就不在，都算成功（调用方要的是「它现在不在了」）。
+package session
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// DeleteResult 删除结果。计数只用于向调用方交代「删掉了什么」，不作判据。
+type DeleteResult struct {
+	ID             string `json:"id"`
+	RecordsRemoved int    `json:"records_removed"`
+	LogsRemoved    int    `json:"logs_removed"`
+	TitlesRemoved  int    `json:"titles_removed"`
+}
+
+// Delete 删掉一条会话：登记记录 + 事件日志 + 标题覆盖。
+// id 可以是 session_id 或 run_id（与 --stop / --session-log 同一套寻址）。
+func Delete(id string) (DeleteResult, error) {
+	out := DeleteResult{ID: strings.TrimSpace(id)}
+	if out.ID == "" {
+		return out, os.ErrInvalid
+	}
+	/* ⚠️ id 要拼进文件名（`<id>.json` / `<id>.jsonl`）→ 必须挡住路径穿越。
+	   插件那条路在 parseSessionPath 里已经挡过一次，这里是**共用实现**，
+	   不能指望每个调用方都记得挡。 */
+	if !safeDeleteID(out.ID) {
+		return out, os.ErrInvalid
+	}
+	dir := Dir()
+	recs, err := List()
+	if err != nil {
+		return out, err
+	}
+	/* ① 先收集「这条会话所有可能的名字」：传进来的 id（可能两个都不在登记表里、
+	   只有日志文件在），加上命中记录自己的 session_id 与 run_id。 */
+	names := map[string]bool{out.ID: true}
+	for _, r := range recs {
+		if r.RunID != out.ID && r.SessionID != out.ID {
+			continue
+		}
+		if r.RunID != "" {
+			names[r.RunID] = true
+		}
+		if r.SessionID != "" {
+			names[r.SessionID] = true
+		}
+	}
+	/* ② 再按名字集合删**这一整条会话**的记录：一条会话每轮落一条（run_id 各不同、
+	   session_id 相同），只删「id 正好等于传进来那个」的那一条，其它轮还在列表里
+	   —— 表现就是「删了没删干净、刷新又冒出来」。 */
+	for _, r := range recs {
+		if !names[r.RunID] && !names[r.SessionID] {
+			continue
+		}
+		if dir == "" || r.RunID == "" {
+			continue
+		}
+		if err := os.Remove(filepath.Join(dir, r.RunID+".json")); err == nil {
+			out.RecordsRemoved++
+		}
+	}
+	for _, logDir := range logDirsForDelete(dir) {
+		for one := range names {
+			if err := os.Remove(logPath(logDir, one)); err == nil {
+				out.LogsRemoved++
+			}
+		}
+	}
+	out.TitlesRemoved = dropTitles(names)
+	return out, nil
+}
+
+// logDirsForDelete 删日志该去哪些目录（去重）。
+//
+// 默认两者是同一个目录（~/.magic-agent/sessions），但它们**能被分别改写**：
+// 登记表目录认 `MAGIC_AGENT_SESSIONS`，日志目录认 `HOME` ——
+// 只查一个目录就会出现「列表里没了、磁盘上还占着」（孤儿日志）。
+func logDirsForDelete(registryDir string) []string {
+	out := make([]string, 0, 2)
+	add := func(d string) {
+		d = strings.TrimSpace(d)
+		if d == "" {
+			return
+		}
+		for _, x := range out {
+			if x == d {
+				return
+			}
+		}
+		out = append(out, d)
+	}
+	add(registryDir)
+	if d, err := DefaultLogDir(); err == nil {
+		add(d)
+	}
+	return out
+}
+
+// safeDeleteID id 能不能安全地当文件名用：非空、非 `.` / `..`、不含路径分隔符与控制字符。
+func safeDeleteID(id string) bool {
+	if id == "" || id == "." || id == ".." {
+		return false
+	}
+	for _, c := range id {
+		if c < 0x20 || c == 0x7f || c == '/' || c == '\\' {
+			return false
+		}
+	}
+	return true
+}
+
+// dropTitles 清掉这些 id 上的标题覆盖，返回清掉的条数。
+//
+// 逐键走 SetTitle（它每次都重新从磁盘读-改-写）：删除是低频动作，
+// 为它多写一条「批量清理」的路径不值当 —— 那条路径迟早会跟单键那条分叉。
+func dropTitles(names map[string]bool) int {
+	n := 0
+	for one := range names {
+		if TitleFor(one) == "" {
+			continue
+		}
+		if err := SetTitle(one, ""); err == nil {
+			n++
+		}
+	}
+	return n
+}

package/internal/session/delete_test.go

@@ -0,0 +1,103 @@
+package session
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+/* Delete：一条会话的**物理删除**（登记记录 + 事件日志 + 标题覆盖）。
+ *
+ * 为什么值得钉（2026-10-19 用户：「从pc端删除的会话移动端还在显示」）：
+ * 列表的权威来源是登记表，各端（PC 的 --sessions、移动端 H5 的 /desk/sessions）读的是同一份。
+ * 删除只要漏掉任何一侧，「一端删了、另一处还在」就会重现：
+ *   · 只删一条 run 记录 → 同一会话的其它轮还在，列表里照旧列着；
+ *   · 只删 <session_id>.jsonl → 引擎整轮没吐 session_id 的那种（日志叫 <run_id>.jsonl）
+ *     会留下孤儿日志：列表里没了、磁盘上还占着；
+ *   · 标题表不清 → 下次同 id 回来时带着旧标题。
+ */
+func TestDeleteRemovesEverything(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+
+	// 一条会话跨两轮：第一轮还没拿到 session_id（日志落在 run_id 上），第二轮才拿到。
+	h1, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid(), PromptHead: "首问"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h1.Finish("sid-1", StateDone)
+	h2, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid(), SessionID: "sid-1", PromptHead: "追问"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h2.Finish("sid-1", StateDone)
+
+	// 两份日志：run_id 那份（首轮没 id 时落的）与 session_id 那份（终名）
+	for _, name := range []string{h1.RunID(), "sid-1"} {
+		if err := os.WriteFile(filepath.Join(dir, name+".jsonl"), []byte("{\"seq\":1}\n"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := SetTitle("sid-1", "某条标题"); err != nil {
+		t.Fatal(err)
+	}
+
+	// 按 **run_id** 删（客户端手上的 id 可能只是某一轮的 run_id）
+	res, err := Delete(h1.RunID())
+	if err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	if res.RecordsRemoved != 2 {
+		t.Errorf("登记记录删了 %d 条，want 2（同一会话的两轮）", res.RecordsRemoved)
+	}
+	if res.LogsRemoved != 2 {
+		t.Errorf("日志删了 %d 份，want 2（<run_id>.jsonl 与 <session_id>.jsonl）", res.LogsRemoved)
+	}
+	if res.TitlesRemoved != 1 {
+		t.Errorf("标题清了 %d 条，want 1", res.TitlesRemoved)
+	}
+	if recs, _ := List(); len(recs) != 0 {
+		t.Errorf("登记表还剩 %d 条记录，want 0（%+v）", len(recs), recs)
+	}
+	for _, name := range []string{h1.RunID(), "sid-1", h2.RunID()} {
+		if fileExists(filepath.Join(dir, name+".jsonl")) {
+			t.Errorf("日志 %s.jsonl 还在", name)
+		}
+	}
+	if got := TitleFor("sid-1"); got != "" {
+		t.Errorf("标题表还有 %q，want 空", got)
+	}
+}
+
+/*
+幂等：id 不认识 / 文件本来就不在 / 再删一次 —— 都算成功。
+
+	客户端的删除入口拿到的可能是一条**只在本地存在**的行（从没进过登记表），
+	它要的是「这条别在我面前出现」，不该因为「本来就没有」而报错。
+*/
+func TestDeleteIsIdempotent(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	for i := 0; i < 2; i++ {
+		res, err := Delete("run-does-not-exist")
+		if err != nil {
+			t.Fatalf("第 %d 次 Delete 报错：%v", i+1, err)
+		}
+		if res.RecordsRemoved != 0 || res.LogsRemoved != 0 {
+			t.Errorf("第 %d 次：删了不存在的记录 %+v，want 全 0", i+1, res)
+		}
+	}
+}
+
+/*
+id 会拼进文件名（`<id>.json` / `<id>.jsonl`）→ 路径穿越必须挡住。
+
+	插件那条路在 parseSessionPath 里挡过一次，本函数是**共用实现**，不能指望调用方都记得挡。
+*/
+func TestDeleteRejectsUnsafeID(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	for _, bad := range []string{"", ".", "..", "../../etc/passwd", "a/b", "a\\b", "x\x00y"} {
+		if _, err := Delete(bad); err == nil {
+			t.Errorf("Delete(%q) 没报错，want 拒绝", bad)
+		}
+	}
+}