magic-agent 1.0.3 → 1.0.49

package/internal/session/session.go

@@ -11,6 +11,11 @@
 // 于是每次调用都落一条记录（引擎子进程 pid + 引擎/模型/工作目录 + 会话 id），
 // 之后任何进程都能用 `magic-agent --stop <session_id|run_id>` 精确停掉它。
 //
+// ⚠️ 2026-10-12 起落盘是** opt-in** 的：CLI 默认不开（BeginOptions.NoPersist），
+// 用户要的是「默认不留痕」—— 手工跑一轮 / CI / 脚本编排事后没人寻址。
+// 开了 --save-registry 的调用方（magic-client）才落；没开的仍会分配 run_id
+// （常驻会话的追加入口按它命名，见 AppendSocketPath），只是磁盘上没有这条记录。
+//
 // 文件位置：$MAGIC_AGENT_SESSIONS > ~/.magic-agent/sessions/<run_id>.json
 // 每条一个文件（无锁、无共享写），过期记录（默认 24h）在 Begin/List/Stop 时顺手清理。
 //
@@ -21,6 +26,12 @@
 //	开始时未知（新会话）              → 结束时回填（Finish），期间用 run_id 寻址
 //
 // 因此 --stop 接受两种 id：会话 id（session_id）或运行 id（run_id，`--sessions` 可见）。
+//
+// 登记表是**全机共享**的：客户端（magic-client）与直接跑的 CLI（用户手工、CI、
+// 别的 magic-* 应用）都往同一份目录里写。所以每条记录还带两个「谁发起的」维度：
+//
+//	Source 设备形态（mobile | pc）—— 界面显示手机 / 电脑标志
+//	Client 发起方应用（如 magic-client）—— 客户端列表据此只显示自己发起的会话
 package session
 
 import (
@@ -39,9 +50,62 @@ import (
 // EnvDir 覆盖登记表目录的环境变量名。
 const EnvDir = "MAGIC_AGENT_SESSIONS"
 
-// Retention 记录保留时长：过期的（按 UpdatedAt）在每次读写时清理。
-// 留着而不是用完即删，是为了让「停一条早就结束的会话」能答出「已结束」而不是「没找到」。
-const Retention = 24 * time.Hour
+// EnvSource 覆盖「会话来源端」的环境变量名（mobile | pc）。
+// 由发起方（HTTP 插件按请求 Origin 判定）注入，core 落到 Record.Source，
+// 界面上据此显示设备标志。空 = 未知（旧记录 / 直接跑 CLI）。
+const EnvSource = "MAGIC_AGENT_SOURCE"
+
+// EnvClient 覆盖「会话来源客户端」的环境变量名（如 magic-client）。
+//
+// 与 EnvSource 是**两个维度**，不能合并：Source 回答「手机还是电脑」，
+// Client 回答「哪个客户端应用发起的」。一台机器上可以同时跑着 magic-client 与
+// 直接跑的 CLI（用户手工 `magic-agent -p …`、CI、别的 magic-* 应用），它们共用
+// 同一份登记表 —— 客户端列表要能只显示**自己发起的**那些（用户 2026-10-12：
+// 「不是 magic-agent 客户端调用的任务不显示」）。
+//
+// 空 = 不是客户端发起的（直接跑 CLI / 旧记录）。
+const EnvClient = "MAGIC_AGENT_CLIENT"
+
+// 来源端取值（只认这两个；其它一律归一成空 = 未知）。
+const (
+	SourceMobile = "mobile"
+	SourcePC     = "pc"
+)
+
+// normalizeSource 把来源端归一：只认 mobile / pc，其余（含空）返回 ""。
+// 不认识的词一律当「未知」，宁可界面显示默认设备，也不要把陌生的值当真。
+func normalizeSource(s string) string {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case SourceMobile:
+		return SourceMobile
+	case SourcePC:
+		return SourcePC
+	default:
+		return ""
+	}
+}
+
+// normalizeClient 归一来源客户端标识：去空白 + 按 rune 截断到 64。
+//
+// 为什么**不**像 Source 那样只认固定几个值：客户端身份是开放词表（每个 magic-*
+// 应用各一个，见 Profile.AppID），core 不该替它们枚举 —— 认得出的原样留下，
+// 认不出的也只是「不显示」而已（客户端按它过滤时对不上就当不是自己的）。
+func normalizeClient(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return ""
+	}
+	r := []rune(s)
+	if len(r) > 64 {
+		return string(r[:64])
+	}
+	return s
+}
+
+/* 登记表**永不按时间清理**（2026-10-18，用户：「永远保留啊 没有24小时限制」）。
+   此前是 `Retention = 24h` + prune 按 UpdatedAt 物理删 —— 后果是历史任务自己从列表里
+   消失：移动端 / 桌面端的「任务」页直接读这份登记表（`--sessions`），删了就等于没跑过。
+   代价可忽略（一条记录约 450 字节）。只清**读不出来的**坏文件，见 dropUnreadable。 */
 
 // 记录状态。
 //
@@ -86,12 +150,23 @@ func isTerminalOverride(s string) bool {
 
 // Record 一条会话记录（也是磁盘上的 JSON 形状）。
 type Record struct {
-	RunID      string    `json:"run_id"`
-	SessionID  string    `json:"session_id,omitempty"`
-	PID        int       `json:"pid"`
-	KillGroup  bool      `json:"kill_group"` // true = 按进程组杀（引擎子进程自成组）
-	Engine     string    `json:"engine"`
-	Model      string    `json:"model,omitempty"`
+	RunID     string `json:"run_id"`
+	SessionID string `json:"session_id,omitempty"`
+	PID       int    `json:"pid"`
+	KillGroup bool   `json:"kill_group"` // true = 按进程组杀（引擎子进程自成组）
+	Engine    string `json:"engine"`
+	Model     string `json:"model,omitempty"`
+	// Source 这条会话的**来源端**：mobile | pc（空 = 未知/旧记录）。
+	// 由发起方经 MAGIC_AGENT_SOURCE 传入（HTTP 插件按请求 Origin 判定），
+	// 界面据此显示设备标志（手机 / 电脑）。
+	Source string `json:"source,omitempty"`
+	// Client 这条会话的**来源客户端**（如 magic-client；空 = 不是客户端发起的）。
+	// 由发起方经 MAGIC_AGENT_CLIENT 传入（magic-client 插件注入自己的 AppID），
+	// 客户端列表据此**只显示自己发起的会话**。
+	//
+	// 与 Source 的分工：Source 是设备形态（手机/电脑），Client 是发起方应用。
+	// 两者都缺一不可 —— 同一台机器上既有客户端发起的、也有直接跑 CLI 的会话。
+	Client     string    `json:"client,omitempty"`
 	Workspace  string    `json:"workspace,omitempty"`
 	PromptHead string    `json:"prompt_head,omitempty"`
 	State      string    `json:"state"`
@@ -119,16 +194,32 @@ func Dir() string {
 type BeginOptions struct {
 	Engine     string
 	Model      string
+	Source     string // 来源端（mobile | pc）；空 = 未知
+	Client     string // 来源客户端（如 magic-client）；空 = 不是客户端发起的
 	Workspace  string
 	SessionID  string // 续接时已知；新会话为空
 	PromptHead string // 提示词开头（便于人辨认）
 	PID        int    // 可先填自身 pid 兜底（引擎子进程起来后会被 SetPID 覆盖）
+	// NoPersist 只在内存里维护这条会话，**不落盘**登记表。
+	//
+	// 为什么要它（用户 2026-10-12：「会话登记也不需要」）：CLI 默认不留痕 ——
+	// 手工跑一轮 / CI / 脚本编排不该在 ~/.magic-agent/sessions/ 里堆记录。
+	// 但 run_id 仍要（常驻会话的追加入口按它命名，见 AppendSocketPath），
+	// 所以「不落盘」不等于「没有这条会话」，只是 --sessions / --stop 看不见它。
+	//
+	// ⚠️ 取反命名（NoPersist 而非 Persist）：默认零值仍是「落盘」，
+	// 既有调用方与测试不必逐个改语义 —— 只有 CLI 显式关它。
+	NoPersist bool
 }
 
 // Handle 一条运行中会话的句柄（负责回写 pid 与收尾状态）。
 type Handle struct {
 	rec  Record
 	path string
+	// noPersist 这条会话不落盘（BeginOptions.NoPersist）：句柄照常分配 run_id、
+	// 照常接受 pid / 状态 / 收尾回写，只是**不写文件** —— 调用方（CLI 默认）
+	// 因此不留痕，而 run_id 仍能当追加入口的地址（见 AppendSocketPath）。
+	noPersist bool
 }
 
 // RunID 本次运行的 id。
@@ -220,7 +311,13 @@ func (h *Handle) KillChild() {
 }
 
 // write 落盘（失败静默：登记表只是可运维性，不能因为它写不动就让调用失败）。
+//
+// noPersist 时**直接跳过** —— 磁盘上根本没有这条记录，SetPID / Mark / Finish
+// 这些回写退化成纯内存操作（值仍留在 h.rec 上，进程内读得到）。
 func (h *Handle) write() {
+	if h.noPersist {
+		return
+	}
 	h.rec.UpdatedAt = time.Now()
 	data, err := json.MarshalIndent(h.rec, "", "  ")
 	if err != nil {
@@ -238,7 +335,7 @@ func (h *Handle) write() {
 	_ = os.Rename(tmp, h.path)
 }
 
-// Begin 新建一条 running 记录。
+// Begin 新建一条 running 记录（NoPersist 时只在内存里建，不落盘）。
 func Begin(o BeginOptions) (*Handle, error) {
 	dir := Dir()
 	if dir == "" {
@@ -247,7 +344,10 @@ func Begin(o BeginOptions) (*Handle, error) {
 	if err := os.MkdirAll(dir, 0o700); err != nil {
 		return nil, err
 	}
-	prune(dir)
+	// 只在真的要落盘时才顺手清坏记录：不留痕的调用没必要为别人清理目录。
+	if !o.NoPersist {
+		dropUnreadable(dir)
+	}
 
 	now := time.Now()
 	rec := Record{
@@ -259,14 +359,18 @@ func Begin(o BeginOptions) (*Handle, error) {
 		KillGroup:  false, // 自身 pid 兜底时按单进程杀（不能杀调用方的进程组）
 		Engine:     o.Engine,
 		Model:      o.Model,
+		Source:     normalizeSource(o.Source),
+		Client:     normalizeClient(o.Client),
 		Workspace:  o.Workspace,
 		PromptHead: head(o.PromptHead, 80),
 		State:      StateRunning,
 		StartedAt:  now,
 		UpdatedAt:  now,
 	}
-	h := &Handle{rec: rec, path: filepath.Join(dir, rec.RunID+".json")}
-	h.write()
+	// path 照样算出来：追加入口的 socket 与它同目录同前缀（见 AppendSocketPath），
+	// 句柄里留着它，SetAppendPath 之类也不用知道自己是不是在存档模式。
+	h := &Handle{rec: rec, path: filepath.Join(dir, rec.RunID+".json"), noPersist: o.NoPersist}
+	h.write() // noPersist 时这里什么都不做
 	return h, nil
 }
 
@@ -280,13 +384,13 @@ func head(s string, n int) string {
 	return string(r[:n]) + "…"
 }
 
-// List 返回全部记录（新的在前）；顺带清理过期记录。
+// List 返回全部记录（新的在前）；顺带清理读不出来的坏文件。
 func List() ([]Record, error) {
 	dir := Dir()
 	if dir == "" {
 		return nil, fmt.Errorf("cannot resolve sessions dir")
 	}
-	prune(dir)
+	dropUnreadable(dir)
 	entries, err := os.ReadDir(dir)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -300,6 +404,9 @@ func List() ([]Record, error) {
 			continue
 		}
 		if rec, err := readRecord(filepath.Join(dir, e.Name())); err == nil {
+			if normalizeDead(&rec) {
+				writeRecord(rec)
+			}
 			out = append(out, rec)
 		}
 	}
@@ -307,6 +414,27 @@ func List() ([]Record, error) {
 	return out, nil
 }
 
+// normalizeDead 把「记录写着在跑，但进程已经不在了」的记录读侧归一成 gone。
+//
+// 为什么必须在读侧做（2026-10-19）：core 被外部杀掉时（客户端断连、终端退出、
+// 宿主服务重启）来不及走 Finish 写终态，磁盘上就永远停着 running ——
+// 界面上表现为任务「一直不结束」，移动端的串行门（同空间存在 running 就排队）
+// 还会被这条死记录永久挡住，新任务永远发不出去。
+//
+// 与 Stop() 的「进程已不在 → gone」判定同口径；PID 缺失（<=0）的老记录无从判断，
+// 保持原样。返回 true 表示状态被改过，调用方需要回写。
+func normalizeDead(rec *Record) bool {
+	if rec.State != StateRunning && rec.State != StateWaitingApproval {
+		return false
+	}
+	if rec.PID <= 0 || agent.PIDAlive(rec.PID) {
+		return false
+	}
+	rec.State = StateGone
+	rec.UpdatedAt = time.Now()
+	return true
+}
+
 // Find 按 run_id 或 session_id 精确匹配一条记录。
 // 同 id 有多条时优先「running」的那条，其次取最新。
 func Find(id string) (Record, bool, error) {
@@ -357,6 +485,11 @@ func Stop(id string) (StopResult, error) {
 	}
 
 	if rec.State != StateRunning {
+		/* gone 是 List() 在读侧归一的「进程已不在」，和下面那条死进程分支是同一件事，
+		   原因文案保持一致（Stop 的调用方据此区分「本来就结束了」与「进程没了」）。 */
+		if rec.State == StateGone {
+			return StopResult{Record: rec, Reason: "进程已不在（可能已自然结束）"}, nil
+		}
 		return StopResult{Record: rec, Reason: "会话已结束（state=" + rec.State + "）"}, nil
 	}
 	if rec.PID <= 0 || !agent.PIDAlive(rec.PID) {
@@ -427,20 +560,22 @@ func writeRecord(rec Record) {
 	_ = os.WriteFile(filepath.Join(dir, rec.RunID+".json"), data, 0o600)
 }
 
-// prune 删除过期记录（按 UpdatedAt；读不动的坏文件一并清掉）。
-func prune(dir string) {
+// dropUnreadable 清掉读不出来的登记文件（写了一半、非法 JSON）。
+//
+// ⚠️ **不按时间清理**：登记表就是「历史任务列表」的数据源，按 UpdatedAt 删过期记录等于
+// 让跑过的任务自己消失（见文件头那条注释）。坏文件仍然要清 —— 它永远读不出来，
+// 留着只是噪音，而且每次 List 都要为它白读一遍。
+func dropUnreadable(dir string) {
 	entries, err := os.ReadDir(dir)
 	if err != nil {
 		return
 	}
-	cutoff := time.Now().Add(-Retention)
 	for _, e := range entries {
 		if e.IsDir() || !strings.HasSuffix(e.Name(), ".json") {
 			continue
 		}
 		p := filepath.Join(dir, e.Name())
-		rec, err := readRecord(p)
-		if err != nil || rec.UpdatedAt.Before(cutoff) {
+		if _, err := readRecord(p); err != nil {
 			_ = os.Remove(p)
 		}
 	}

package/internal/session/session_append.go

@@ -124,24 +124,52 @@ func (a *Appender) Close() {
 	}
 }
 
-// ListenAppend 为一条会话开追加入口，并把路径写进会话记录（客户端据此找到它）。
+// AppendTransportAvailable 报告本平台是否具备「追加入口」的传输能力。
+//
+// 存在的意义（2026-10-01）：Windows 没有 unix domain socket，
+// ListenAppend 在那里必然失败。调用方（cli 层 kaEnabled）据此**提前**判定，
+// 让「默认值触发的常驻」在 Windows 上静默不启用 —— 而不是让用户撞上
+// 「--keep-alive: 常驻会话目前只支持 macOS/Linux」这种
+// 「我没要求它开、它却报错」的错。
+//
+// 显式传 --keep-alive 时仍应报错（用户明确要了这件事，要说清为什么不行），
+// 那个判断在 cli 层的 prepareAsk，不在这里。
+func AppendTransportAvailable() bool {
+	return runtime.GOOS != "windows"
+}
+
+// AppendSocketPath 按约定推出某条会话的追加入口路径：<sessions dir>/<id>.sock。
+//
+// 为什么要它独立于登记表（用户 2026-10-12：默认不留档）：socket 路径本来就**只由
+// run_id 决定**，登记表只是把它「发布」出去让调用方能发现。不落盘时没有发布，
+// 但按同一个约定推就能找到 —— 于是「默认开着常驻、却追加不了」这个坑不会出现。
+// ListenAppend 与 AppendMessage 都走这里，保证两端算出的是同一个路径。
+func AppendSocketPath(id string) string {
+	dir := Dir()
+	if dir == "" || strings.TrimSpace(id) == "" {
+		return ""
+	}
+	return filepath.Join(dir, strings.TrimSpace(id)+".sock")
+}
+
+// ListenAppend 为一条会话开追加入口，并把路径写进会话记录（存档模式下客户端据此找到它）。
 //
 // 目录/文件权限：sessions 目录 0700、socket 文件 0600 → 仅同用户可连。
 func ListenAppend(h *Handle) (*Appender, error) {
 	if h == nil {
 		return nil, fmt.Errorf("no session handle")
 	}
-	if runtime.GOOS == "windows" {
+	if !AppendTransportAvailable() {
 		return nil, fmt.Errorf("常驻会话（--keep-alive）与 --append 目前只支持 macOS/Linux：Windows 没有 unix domain socket")
 	}
-	dir := Dir()
-	if dir == "" {
+	path := AppendSocketPath(h.RunID())
+	if path == "" {
 		return nil, fmt.Errorf("cannot resolve sessions dir")
 	}
+	dir := filepath.Dir(path)
 	if err := os.MkdirAll(dir, 0o700); err != nil {
 		return nil, err
 	}
-	path := filepath.Join(dir, h.RunID()+".sock")
 	// unix socket 路径有硬上限（macOS sun_path 104 / Linux 108 字节），超了 bind 会报
 	// 一句看不出原因的 "invalid argument"。提前拦住并给出可操作建议。
 	if len(path) > maxUnixSocketPath {
@@ -158,7 +186,7 @@ func ListenAppend(h *Handle) (*Appender, error) {
 		_ = ln.Close()
 		return nil, fmt.Errorf("chmod %s: %w", path, err)
 	}
-	h.SetAppendPath(path)
+	h.SetAppendPath(path) // 存档模式下写进记录；不落盘时是空操作
 	return &Appender{ln: ln, path: path}, nil
 }
 
@@ -171,6 +199,11 @@ type AppendResult struct {
 
 // AppendMessage 把一条消息追加进指定会话（session_id 或 run_id 都收）。
 //
+// 两条寻址路径（默认不留档的必然结果）：
+//  1. 登记表里有这条记录 → 读它的 Append 字段（存档模式的老路，session_id 也认）；
+//  2. **没有记录** → 按约定推 <dir>/<run_id>.sock 再试（不落盘时唯一可走的路，
+//     此时只认 run_id —— session_id 要靠记录映射，没有记录就无从查起）。
+//
 // 失败分两种，调用方按退出码区分：
 //   - 找不到 id / 记录里没有追加入口 → 返回 error（exit 1，附可操作提示）
 //   - 常驻进程已经退出（连接被拒）→ 返回 error（exit 1，提示会话已结束）
@@ -184,7 +217,20 @@ func AppendMessage(id, text string) (AppendResult, error) {
 		return AppendResult{}, err
 	}
 	if !found {
-		return AppendResult{}, fmt.Errorf("no such session %q（--sessions 可列出全部）", id)
+		// 没有登记记录：多半是这条会话没开 --save-registry。按约定找 socket。
+		path := AppendSocketPath(id)
+		if path == "" {
+			return AppendResult{}, fmt.Errorf("cannot resolve sessions dir")
+		}
+		if _, serr := os.Stat(path); serr != nil {
+			return AppendResult{}, fmt.Errorf(
+				"no such session %q（既没有登记记录，也没有追加入口 %s；"+
+					"该会话多半是默认不留档跑起来的 —— 常驻会话要用 --save-registry 启动才能按 id 追加）", id, path)
+		}
+		if aerr := appendOverSocket(path, msg); aerr != nil {
+			return AppendResult{}, aerr
+		}
+		return AppendResult{Queued: true}, nil
 	}
 	if strings.TrimSpace(rec.Append) == "" {
 		reason := "该会话没有追加入口（未用 --keep-alive 启动）"
@@ -199,36 +245,48 @@ func AppendMessage(id, text string) (AppendResult, error) {
 			fmt.Errorf("会话已结束（state=%s）；请用 --session <id> 续接", rec.State)
 	}
 
-	conn, derr := net.DialTimeout("unix", rec.Append, 5*time.Second)
-	if derr != nil {
+	if aerr := appendOverSocket(rec.Append, msg); aerr != nil {
 		// 记录说在跑、socket 却连不上：常驻进程多半刚退出（或崩了）
-		rec.State = StateGone
-		rec.UpdatedAt = time.Now()
-		writeRecord(rec)
-		return AppendResult{Record: rec, Reason: "常驻进程已不在（连接失败）"},
-			fmt.Errorf("连不上会话 %s 的追加入口（%s）：常驻进程可能已退出；请用 --sessions 复核", id, rec.Append)
+		if strings.Contains(aerr.Error(), "连不上") {
+			rec.State = StateGone
+			rec.UpdatedAt = time.Now()
+			writeRecord(rec)
+		}
+		return AppendResult{Record: rec, Reason: "常驻进程已不在（连接失败）"}, aerr
+	}
+	rec.UpdatedAt = time.Now()
+	writeRecord(rec)
+	return AppendResult{Record: rec, Queued: true}, nil
+}
+
+// appendOverSocket 连上追加入口投递一条消息并等应答。
+//
+// 单独抽出来是为了让「有记录」与「按约定找 socket」两条路径共用同一套协议 ——
+// 协议改一处就够；两处各写一遍的话，改一处忘一处是迟早的事。
+func appendOverSocket(path, msg string) error {
+	conn, derr := net.DialTimeout("unix", path, 5*time.Second)
+	if derr != nil {
+		return fmt.Errorf("连不上会话的追加入口（%s）：常驻进程可能已退出；请用 --sessions 复核", path)
 	}
 	defer conn.Close()
 	_ = conn.SetDeadline(time.Now().Add(15 * time.Second))
 
 	req, _ := json.Marshal(appendRequest{Version: AppendProtocolVersion, Text: msg})
 	if _, werr := conn.Write(append(req, '\n')); werr != nil {
-		return AppendResult{Record: rec, Reason: "写入失败"}, fmt.Errorf("写入追加入口失败: %w", werr)
+		return fmt.Errorf("写入追加入口失败: %w", werr)
 	}
 	line, rerr := bufio.NewReader(conn).ReadString('\n')
 	if rerr != nil && strings.TrimSpace(line) == "" {
-		return AppendResult{Record: rec, Reason: "没收到应答"}, fmt.Errorf("追加入口没回应: %w", rerr)
+		return fmt.Errorf("追加入口没回应: %w", rerr)
 	}
 	var resp appendResponse
 	if jerr := json.Unmarshal([]byte(strings.TrimSpace(line)), &resp); jerr != nil {
-		return AppendResult{Record: rec, Reason: "应答不是 JSON"}, fmt.Errorf("追加入口应答异常: %s", strings.TrimSpace(line))
+		return fmt.Errorf("追加入口应答异常: %s", strings.TrimSpace(line))
 	}
 	if !resp.OK {
-		return AppendResult{Record: rec, Reason: resp.Error}, fmt.Errorf("追加被拒: %s", resp.Error)
+		return fmt.Errorf("追加被拒: %s", resp.Error)
 	}
-	rec.UpdatedAt = time.Now()
-	writeRecord(rec)
-	return AppendResult{Record: rec, Queued: true}, nil
+	return nil
 }
 
 // SetAppendPath 把追加入口路径写进记录（由 ListenAppend 调用）。

package/internal/session/session_test.go

@@ -3,7 +3,7 @@ package session
 // session_test.go - 会话登记表单元测试。
 //
 // 覆盖：Begin 落盘（running）/ pid 与 session_id 回填 / 按 run_id 与 session_id 查找 /
-// Stop（真杀进程、幂等、未知 id、已结束）/ 过期清理 / Finish 不覆盖 stopped。
+// Stop（真杀进程、幂等、未知 id、已结束）/ 老记录保留（只清坏文件）/ Finish 不覆盖 stopped。
 //
 // 全部用临时目录（t.Setenv(EnvDir)），不碰用户真实登记表。
 
@@ -193,22 +193,24 @@ func TestFinishKeepsStoppedState(t *testing.T) {
 	}
 }
 
-func TestListPrunesExpiredRecords(t *testing.T) {
+// 登记表**不按时间清理**：老记录必须留着（2026-10-18，用户：「永远保留啊 没有24小时限制」）。
+// 只有读不出来的坏文件才清 —— 它永远读不出来，留着只是噪音。
+func TestListKeepsOldRecordsDropsBroken(t *testing.T) {
 	dir := isolate(t)
 
-	// 手工塞一条 25 小时前的记录（Retention = 24h）
+	// 手工塞一条 25 天前的记录：以前会被当「过期」删掉，现在必须原样留着。
 	old := Record{
 		RunID:     "run-old",
 		Engine:    "claude",
 		State:     StateDone,
-		StartedAt: time.Now().Add(-25 * time.Hour),
-		UpdatedAt: time.Now().Add(-25 * time.Hour),
+		StartedAt: time.Now().Add(-25 * 24 * time.Hour),
+		UpdatedAt: time.Now().Add(-25 * 24 * time.Hour),
 	}
 	data, _ := json.Marshal(old)
 	if err := os.WriteFile(filepath.Join(dir, "run-old.json"), data, 0o600); err != nil {
 		t.Fatal(err)
 	}
-	// 再来一条坏的（非法 JSON）也应被清掉
+	// 坏文件（非法 JSON）读不出来 → 清掉。
 	if err := os.WriteFile(filepath.Join(dir, "run-broken.json"), []byte("{not json"), 0o600); err != nil {
 		t.Fatal(err)
 	}
@@ -217,11 +219,14 @@ func TestListPrunesExpiredRecords(t *testing.T) {
 	if err != nil {
 		t.Fatalf("List: %v", err)
 	}
-	if len(all) != 0 {
-		t.Errorf("过期/坏记录应被清掉, got %+v", all)
+	if len(all) != 1 || all[0].RunID != "run-old" {
+		t.Errorf("老记录应保留、坏记录应被清掉, got %+v", all)
 	}
-	if _, err := os.Stat(filepath.Join(dir, "run-old.json")); !os.IsNotExist(err) {
-		t.Error("过期文件应已删除")
+	if _, err := os.Stat(filepath.Join(dir, "run-old.json")); err != nil {
+		t.Error("老记录文件不该被删除")
+	}
+	if _, err := os.Stat(filepath.Join(dir, "run-broken.json")); !os.IsNotExist(err) {
+		t.Error("坏文件应已删除")
 	}
 }
 
@@ -235,3 +240,112 @@ func TestDirPrefersEnv(t *testing.T) {
 		t.Errorf("Dir() = %q want /tmp/x-sessions", got)
 	}
 }
+
+// NoPersist：默认不留痕时磁盘上什么都没有，但 run_id 仍要照常分配
+// （常驻会话的追加入口按它命名 —— 见 AppendSocketPath）。
+func TestBeginNoPersistLeavesNoRecord(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+	h, err := Begin(BeginOptions{Engine: "claude", NoPersist: true})
+	if err != nil {
+		t.Fatalf("Begin: %v", err)
+	}
+	if h.RunID() == "" {
+		t.Fatal("不留盘也要有 run_id（追加入口靠它命名）")
+	}
+	// 句柄内的回写照常可用（纯内存），只是不落文件。
+	h.SetPID(4321, true)
+	h.Mark(StateWaitingApproval)
+	h.Finish("sid-x", StateDone)
+	if got := h.Record().State; got != StateDone {
+		t.Errorf("内存里的状态应是 done，实际 %q", got)
+	}
+	ents, _ := os.ReadDir(dir)
+	for _, e := range ents {
+		if strings.HasSuffix(e.Name(), ".json") {
+			t.Errorf("NoPersist 不该落登记记录，却有 %s", e.Name())
+		}
+	}
+	if recs, err := List(); err != nil || len(recs) != 0 {
+		t.Errorf("List() 应为空：%+v (err=%v)", recs, err)
+	}
+}
+
+// AppendSocketPath 与 ListenAppend 必须算出同一个路径 —— 不留档时 --append
+// 靠的就是这个约定（没有登记表发布 socket 地址）。
+func TestAppendSocketPathMatchesListen(t *testing.T) {
+	// 用短目录（isolate）：unix socket 路径有 104 字节硬上限，t.TempDir() 那种长路径
+	// 会直接 bind 失败 —— 这正是 isolate 存在的理由。
+	isolate(t)
+	h, err := Begin(BeginOptions{Engine: "claude", NoPersist: true})
+	if err != nil {
+		t.Fatalf("Begin: %v", err)
+	}
+	ap, err := ListenAppend(h)
+	if err != nil {
+		t.Fatalf("ListenAppend: %v", err)
+	}
+	defer ap.Close()
+	if got, want := ap.Path(), AppendSocketPath(h.RunID()); got != want {
+		t.Errorf("socket 路径不一致：建出来 %q，按约定推 %q", got, want)
+	}
+	if _, serr := os.Stat(AppendSocketPath(h.RunID())); serr != nil {
+		t.Errorf("按约定推出的路径上应有 socket 文件：%v", serr)
+	}
+}
+
+// 来源端归一（2026-10-11）：只认 mobile / pc，其余（含空、大小写、带空白）一律 ""。
+// 认错比认不出更糟，所以陌生值必须落回未知（界面走默认设备）。
+func TestNormalizeSource(t *testing.T) {
+	cases := map[string]string{
+		"mobile": "mobile", "MOBILE": "mobile", " mobile ": "mobile",
+		"pc": "pc", "PC": "pc",
+		"": "", "  ": "", "desktop": "", "ios": "",
+	}
+	for in, want := range cases {
+		if got := normalizeSource(in); got != want {
+			t.Errorf("normalizeSource(%q) = %q want %q", in, got, want)
+		}
+	}
+}
+
+// 来源客户端（2026-10-12）是**开放词表**：各 magic-* 应用各一个（见 Profile.AppID），
+// core 不该枚举它。所以这里只钉两件事：空白归一为空、超长按 rune 截断（不切坏中文）。
+func TestNormalizeClient(t *testing.T) {
+	for _, c := range []struct{ in, want string }{
+		{"magic-client", "magic-client"},
+		{"  magic-client  ", "magic-client"},
+		{"", ""},
+		{"   ", ""},
+	} {
+		if got := normalizeClient(c.in); got != c.want {
+			t.Errorf("normalizeClient(%q) = %q want %q", c.in, got, c.want)
+		}
+	}
+	long := strings.Repeat("客户端", 40) // 120 rune > 64
+	got := normalizeClient(long)
+	// 判据是「截断后仍是一个完整 rune 序列」：直接比前 64 个 rune，
+	// 顺带钉住边界 —— 64 不是 3 的整数倍，所以末位落在「客」上（按字节切就会切出半个字）。
+	want := string([]rune(long)[:64])
+	if got != want {
+		t.Errorf("超长应按 rune 截到 64：got %d rune want %d rune", len([]rune(got)), len([]rune(want)))
+	}
+}
+
+// Begin 要把来源客户端落进记录（客户端列表据此过滤），且过长的值被截断。
+func TestBeginRecordsClient(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+	h, err := Begin(BeginOptions{Engine: "claude", Client: "  magic-client  "})
+	if err != nil {
+		t.Fatalf("Begin: %v", err)
+	}
+	if got := h.Record().Client; got != "magic-client" {
+		t.Errorf("Record.Client = %q want magic-client", got)
+	}
+	// 落盘后读回来仍是它（客户端重启后列表还要靠它过滤）。
+	recs, err := List()
+	if err != nil || len(recs) != 1 || recs[0].Client != "magic-client" {
+		t.Errorf("List 读回的 client 不对: %+v (err=%v)", recs, err)
+	}
+}