magic-agent 1.0.3 → 1.0.49

package/internal/cli/session.go

@@ -14,11 +14,11 @@ package cli
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"os"
 	"os/signal"
-	"path/filepath"
 	"strings"
 	"sync"
 	"syscall"
@@ -106,17 +106,27 @@ type keepAlive struct {
 	closed    bool          // 收工后为 true：Push 据此拒收（与 close(in) 同锁，避免向已关闭通道发送）
 }
 
-// kaEnabled 常驻会话是否生效：只在「流式 + 引擎支持追加」时才有意义 —— 不满足就静默
-// 不启用（不影响原有调用形态）。显式传 `--keep-alive` 却不满足条件的报错在 prepareAsk
-// 里（那里能拿到 cmd 与引擎）。
+// kaEnabled 常驻会话是否生效：只在「流式 + 引擎支持追加 + 本平台有追加入口」时才有意义
+// —— 不满足就静默不启用（不影响原有调用形态）。显式传 `--keep-alive` 却不满足条件的
+// 报错在 prepareAsk 里（那里能拿到 cmd 与引擎）。
 //
 // 默认值语义**按引擎区分**（agent.AppendDefaultOn）：claude/codebuddy 默认常驻
 // （用户 2026-09-18 的要求）；dsh 默认关、要显式 `--keep-alive` —— 它的 SDK 通道本来
 // 就是一次一轮的形态，默认挂 5 分钟空闲窗口会让既有调用方以为命令卡住了。
+//
+// ⚠️ 平台维度（2026-10-01）：Windows 没有 unix domain socket，追加入口开不出来。
+//
+//	若仍按引擎默认值返回 true，用户**没要求**常驻却会撞上
+//	「--keep-alive: 只支持 macOS/Linux」的报错 —— 默认值不该制造错误。
+//	故这里按传输能力收敛：Windows 上默认值一律视为关；
+//	**显式** --keep-alive=true 仍由 prepareAsk 报错（用户明确要了，要说清为什么不行）。
 func kaEnabled(cmd *cobra.Command, opts *askOptions, engine string) bool {
 	if !opts.stream || !agent.AppendSupportOf(engine) {
 		return false
 	}
+	if !session.AppendTransportAvailable() {
+		return false
+	}
 	if flagChanged(cmd, "keep-alive") {
 		return opts.keepAlive // 显式开关优先于引擎默认值
 	}
@@ -324,12 +334,28 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 		PID        int    `json:"pid"`
 		Engine     string `json:"engine"`
 		Model      string `json:"model,omitempty"`
+		Source     string `json:"source,omitempty"`
+		Client     string `json:"client,omitempty"`
 		State      string `json:"state"`
 		Alive      bool   `json:"alive"`
 		Workspace  string `json:"workspace,omitempty"`
 		PromptHead string `json:"prompt_head,omitempty"`
-		StartedAt  string `json:"started_at"`
-		UpdatedAt  string `json:"updated_at"`
+		// Title 这条会话的**可展示标题**：优先标题表里的归纳结果（--summarize-title 写的），
+		// 没有就回落 prompt_head。
+		//
+		// 为什么由 CLI 给（2026-10-15，用户：「应该 magic-agent 统一归纳作为会话标题」）：
+		// 归纳口径收进 core 之后，标题就该由 core 给一个确定值 —— 客户端各自
+		// 「TITLES[id] || prompt_head」地拼，迟早在「哪份优先」上分叉（这正是此前
+		// PC 与移动端显示不同标题的原因）。这里给最终值，两端只渲染。
+		Title string `json:"title"`
+		// TitleSummarized 这个 title 是**真归纳出来的**，还是仅仅回落成了 prompt_head。
+		//
+		// 为什么必须单独给一个布尔：title 恒非空（回落也有值），所以客户端**无法**用
+		// 「title 为空」判断「还没归纳」—— 那样写出来的自动归纳会永远不触发（静默失效，
+		// 界面上只是标题一直显示首问原文，看不出是 bug）。客户端要补归纳就认这个字段。
+		TitleSummarized bool   `json:"title_summarized"`
+		StartedAt       string `json:"started_at"`
+		UpdatedAt       string `json:"updated_at"`
 		// HasLog 这条会话有没有**可回放的事件日志**（`--session-log` 读的就是它）。
 		// 为什么让 CLI 来说这件事：日志**只在流式调用时写**（见 sessionlog.go 的 sessionWriter），
 		// 所以非流式跑出来的会话没有历史可回放 —— 客户端要拿它判断「这条点开有东西看吗」，
@@ -339,32 +365,43 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 	logDir, _ := sessionLogDir()
 	rows := make([]row, 0, len(records))
 	for _, r := range records {
+		/* 标题的键可能是 session_id，也可能是 run_id（首轮归纳时引擎还没吐 id，见
+		   session.TitleForAny）—— 两个都认，且**一次取定**，免得两个客户端因为
+		   「谁先拿到 id」而显示不同标题。取不到才回落 prompt_head（= 还没归纳）。 */
+		title := session.TitleForAny(r.SessionID, r.RunID)
+		summarized := title != ""
+		if title == "" {
+			title = r.PromptHead
+		}
 		rows = append(rows, row{
-			RunID:      r.RunID,
-			SessionID:  r.SessionID,
-			PID:        r.PID,
-			Engine:     r.Engine,
-			Model:      r.Model,
-			State:      r.State,
-			Alive:      r.State == session.StateRunning,
-			Workspace:  r.Workspace,
-			PromptHead: r.PromptHead,
-			StartedAt:  r.StartedAt.Format("2006-01-02 15:04:05"),
-			UpdatedAt:  r.UpdatedAt.Format("2006-01-02 15:04:05"),
-			HasLog:     hasSessionLog(logDir, r.SessionID),
+			RunID:           r.RunID,
+			SessionID:       r.SessionID,
+			PID:             r.PID,
+			Engine:          r.Engine,
+			Model:           r.Model,
+			Source:          r.Source,
+			Client:          r.Client,
+			State:           r.State,
+			Alive:           r.State == session.StateRunning,
+			Workspace:       r.Workspace,
+			PromptHead:      r.PromptHead,
+			Title:           title,
+			TitleSummarized: summarized,
+			StartedAt:       r.StartedAt.Format("2006-01-02 15:04:05"),
+			UpdatedAt:       r.UpdatedAt.Format("2006-01-02 15:04:05"),
+			HasLog:          hasSessionLog(logDir, r),
 		})
 	}
 	return printJSON(cmd.OutOrStdout(), rows)
 }
 
-// hasSessionLog 这条记录有没有事件日志：日志按 `session_id` 命名，所以没有 id 的
-// （一次性调用）自然没有；还要看文件在不在、非空 —— 空文件等于没有可回放的内容。
-func hasSessionLog(dir, sessionID string) bool {
-	if dir == "" || sessionID == "" {
-		return false
-	}
-	st, err := os.Stat(filepath.Join(dir, sessionID+".jsonl"))
-	return err == nil && st.Size() > 0
+// hasSessionLog 这条记录有没有可回放的事件日志。
+//
+// 日志文件名可能是 **session_id**（终名），也可能是 **run_id** —— 引擎还没吐 id 时
+// core 先按 run_id 落盘（见 sessionlog.go 的 setRunID / renameTo），所以两个名字都试一次；
+// 决议逻辑（含 run_id → session_id 的翻译）在 session.HasSessionLog 里，读接口共用同一份。
+func hasSessionLog(dir string, rec session.Record) bool {
+	return session.HasSessionLog(dir, rec.SessionID) || session.HasSessionLog(dir, rec.RunID)
 }
 
 // runSessionLog 读一段会话的**事件历史**：`--session-log <id> [--after <seq>]`。
@@ -386,15 +423,76 @@ func runSessionLog(cmd *cobra.Command, opts *askOptions) error {
 	if err != nil {
 		return fmt.Errorf("--session-log %s: 找不到历史目录: %w", id, err)
 	}
+	/* 传进来的可能是 run_id（登记表里的运行 id）：日志文件名按 session_id 落，
+	   所以先翻一次名 —— 否则「点开正在跑的会话」永远读到空历史（静默）。
+	   见 session.ResolveLogID。翻译后的 id 也**照实回报**（输出的 session 字段），
+	   客户端据此就能知道这条会话真正的 session_id。 */
+	id = session.ResolveLogID(dir, id)
+
+	// --after（向后追新）与 --before（向前翻旧）是两条相反的路：一次只能走一条，
+	// 同时给必然是调用方拼错了参数 —— 明说，不静默挑一个。
+	if flagChanged(cmd, "after") && flagChanged(cmd, "before") {
+		return &usageError{fmt.Errorf("--after 与 --before 互斥：--after 向后追新，--before 向前翻更早的历史，一次只能用一条")}
+	}
+	if flagChanged(cmd, "before") {
+		limit := opts.logLimit
+		if limit <= 0 {
+			limit = 200
+		}
+		var evs []sessionEvent
+		var nextBefore uint64
+		var more bool
+		var err error
+		if opts.logLean {
+			evs, nextBefore, more, err = ReadSessionLogBeforeLean(dir, id, opts.logBefore, limit)
+		} else {
+			evs, nextBefore, more, err = ReadSessionLogBefore(dir, id, opts.logBefore, limit)
+		}
+		if err != nil {
+			return fmt.Errorf("--session-log %s: %w", id, err)
+		}
+		if evs == nil {
+			evs = []sessionEvent{}
+		}
+		if opts.logLean {
+			stripSnapshots(evs) // 双保险，同 --after 分支
+		}
+		// 页头对齐（切到轮次起点的 user）与下一页游标都在 core 里算：被裁掉的几条
+		// 会由下一页补回，调用方拿 nextBefore 继续翻即可，不重不漏。
+		var firstSeq uint64
+		if len(evs) > 0 {
+			firstSeq = evs[0].Seq
+		}
+		return printJSON(cmd.OutOrStdout(), struct {
+			Session    string         `json:"session"`
+			Events     []sessionEvent `json:"events"`
+			Count      int            `json:"count"`
+			Before     uint64         `json:"before"`
+			NextBefore uint64         `json:"nextBefore"`
+			FirstSeq   uint64         `json:"firstSeq"`
+			More       bool           `json:"more"`
+		}{Session: id, Events: evs, Count: len(evs), Before: opts.logBefore,
+			NextBefore: nextBefore, FirstSeq: firstSeq, More: more})
+	}
 
 	if flagChanged(cmd, "after") {
-		evs, maxSeq, err := ReadSessionLogAfter(dir, id, opts.logAfter)
+		var evs []sessionEvent
+		var maxSeq uint64
+		var err error
+		if opts.logLean {
+			evs, maxSeq, err = ReadSessionLogAfterLean(dir, id, opts.logAfter)
+		} else {
+			evs, maxSeq, err = ReadSessionLogAfter(dir, id, opts.logAfter)
+		}
 		if err != nil {
 			return fmt.Errorf("--session-log %s: %w", id, err)
 		}
 		if evs == nil {
 			evs = []sessionEvent{}
 		}
+		if opts.logLean {
+			stripSnapshots(evs) // 双保险：lean 读已摘过，这里只兜住未来的新调用方
+		}
 		return printJSON(cmd.OutOrStdout(), struct {
 			Session string         `json:"session"`
 			Events  []sessionEvent `json:"events"`
@@ -408,13 +506,21 @@ func runSessionLog(cmd *cobra.Command, opts *askOptions) error {
 			LastSeq: maxSeq, SnapshotRequired: opts.logAfter > maxSeq})
 	}
 
-	evs, err := ReadSessionLog(dir, id)
+	var evs []sessionEvent
+	if opts.logLean {
+		evs, err = ReadSessionLogLean(dir, id)
+	} else {
+		evs, err = ReadSessionLog(dir, id)
+	}
 	if err != nil {
 		return fmt.Errorf("--session-log %s: %w", id, err)
 	}
 	if evs == nil {
 		evs = []sessionEvent{}
 	}
+	if opts.logLean {
+		stripSnapshots(evs) // 双保险，同上面 --after 分支
+	}
 	return printJSON(cmd.OutOrStdout(), struct {
 		Session string         `json:"session"`
 		Events  []sessionEvent `json:"events"`
@@ -482,6 +588,47 @@ func stopText(res session.StopResult) string {
 	return fmt.Sprintf("magic-agent: 会话 %s 未在运行：%s（state=%s）", who, reason, res.Record.State)
 }
 
+// runDeleteSession 删除一条会话：登记记录 + 事件日志 + 标题覆盖（见 session.Delete）。
+//
+// 退出码：0 已删除 / 本来就不在（幂等）；2 参数错（空 id / id 里带路径分隔符）。
+//
+// ⚠️ 这是**全机生效**的物理删除 —— 各端读的都是同一份登记表，一端删了处处都看不到。
+// 客户端把它当成「删除」这个动作的唯一实现，别只在本地记墓碑（那正是
+// 「从pc端删除的会话移动端还在显示」的原因）。
+func runDeleteSession(cmd *cobra.Command, opts *askOptions) error {
+	id := strings.TrimSpace(opts.deleteSession)
+	if id == "" {
+		return &usageError{fmt.Errorf("--delete-session 需要一个 session_id 或 run_id（--sessions 可列出全部）")}
+	}
+	res, err := session.Delete(id)
+	if err != nil {
+		if errors.Is(err, os.ErrInvalid) {
+			return &usageError{fmt.Errorf("--delete-session %q：id 不能为空，也不能含路径分隔符 / 控制字符", id)}
+		}
+		return fmt.Errorf("--delete-session %s: %w", id, err)
+	}
+	if opts.output == "text" {
+		_, _ = fmt.Fprintf(cmd.OutOrStdout(),
+			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条）\n",
+			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved)
+		return nil
+	}
+	out := struct {
+		Type           string `json:"type"`
+		ID             string `json:"id"`
+		RecordsRemoved int    `json:"records_removed"`
+		LogsRemoved    int    `json:"logs_removed"`
+		TitlesRemoved  int    `json:"titles_removed"`
+	}{
+		Type:           "delete",
+		ID:             res.ID,
+		RecordsRemoved: res.RecordsRemoved,
+		LogsRemoved:    res.LogsRemoved,
+		TitlesRemoved:  res.TitlesRemoved,
+	}
+	return writeJSONLine(cmd.OutOrStdout(), out)
+}
+
 // writeJSONLine 写一行 JSON（复用 printJSON 的编码方式，单独留个名便于阅读）。
 func writeJSONLine(w io.Writer, v any) error {
 	data, err := json.Marshal(v)

package/internal/cli/session_test.go

@@ -19,12 +19,110 @@ import (
 	"github.com/darren/magic-agent/internal/session"
 )
 
-// sessionRows 解析 --sessions 的 JSON 输出。
+// TestSummarizeTitleCachedAcrossKeys 追问轮按 session_id 归纳时，应命中首轮存在 run_id 上的
+// 标题（不调 LLM），并把它迁到 session_id 上 —— 否则每轮追问都会重算一次标题。
+//
+// 用户 2026-10-15 报的「标题每次追问也在更新」就是这条链路：键落在会变的 run_id 上 +
+// 归纳输入回落成**当前这轮**的 prompt_head。
+func TestSummarizeTitleCachedAcrossKeys(t *testing.T) {
+	t.Setenv(session.EnvDir, t.TempDir())
+	oldLog := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = oldLog }()
+	SessionLogDirOverride = t.TempDir()
+	registerFake(&userEchoStreamEngine{name: "fake-title-a", sessionID: "sess-t1"})
+
+	if _, _, err := runAskCmd(t, "", "--save-registry", "--save-history",
+		"-e", "fake-title-a", "--stream", "第一句需求"); err != nil {
+		t.Fatalf("ask: %v", err)
+	}
+	rows := parseSessions(t, mustSessions(t))
+	if len(rows) != 1 || rows[0].SessionID != "sess-t1" {
+		t.Fatalf("前置条件不成立（应有 1 条带 session_id 的记录）：%+v", rows)
+	}
+	// 模拟首轮归纳的结果：键留在了那一轮的 run_id 上。
+	if err := session.SetTitle(rows[0].RunID, "初次归纳的标题"); err != nil {
+		t.Fatal(err)
+	}
+
+	out, _, err := runAskCmd(t, "", "--summarize-title", "sess-t1")
+	if err != nil {
+		t.Fatalf("跨键应命中缓存、不该报错：%v", err)
+	}
+	if !strings.Contains(out, "初次归纳的标题") || !strings.Contains(out, `"cached":true`) {
+		t.Fatalf("应回现有标题且 cached=true，实际 %s", out)
+	}
+	if session.TitleFor("sess-t1") == "" {
+		t.Fatal("命中时应把标题迁到 session_id 上（否则下一轮又要重算）")
+	}
+}
+
+// TestSummarizeTitleCachedFromOlderRun 标题挂在**上一轮**的 run_id 上（首轮归纳时还没有
+// session_id）→ 追问轮按 session_id 归纳必须命中它、**不重写**标题。
+func TestSummarizeTitleCachedFromOlderRun(t *testing.T) {
+	t.Setenv(session.EnvDir, t.TempDir())
+	oldLog := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = oldLog }()
+	SessionLogDirOverride = t.TempDir()
+	registerFake(&userEchoStreamEngine{name: "fake-title-c", sessionID: "sess-t3"})
+
+	// 同一会话跑两轮（同一个 session_id、两个 run_id）。
+	for _, prompt := range []string{"第一句", "追问一句"} {
+		if _, _, err := runAskCmd(t, "", "--save-registry",
+			"-e", "fake-title-c", "--stream", prompt); err != nil {
+			t.Fatalf("ask: %v", err)
+		}
+	}
+	rows := parseSessions(t, mustSessions(t))
+	if len(rows) != 2 {
+		t.Fatalf("应有两轮记录，实得 %d", len(rows))
+	}
+	// 把标题挂在**较早**那一轮上（rows 是新→旧）。
+	if err := session.SetTitle(rows[1].RunID, "第一次生成的标题"); err != nil {
+		t.Fatal(err)
+	}
+
+	out, _, err := runAskCmd(t, "", "--summarize-title", "sess-t3")
+	if err != nil {
+		t.Fatalf("应命中已有标题、不该报错：%v", err)
+	}
+	if !strings.Contains(out, "第一次生成的标题") || !strings.Contains(out, `"cached":true`) {
+		t.Fatalf("应回第一次生成的标题且 cached=true，实际 %s", out)
+	}
+	if got := session.TitleFor("sess-t3"); got != "第一次生成的标题" {
+		t.Fatalf("应把标题归一到 session_id 上，实得 %q", got)
+	}
+}
+
+// TestSummarizeTitleNeedsFirstPrompt 有 session_id 但没有事件日志时**拒绝**归纳：
+// prompt_head 记的是**当前这轮**的提示词，追问轮拿它当首问，标题就会跟着最新追问变。
+func TestSummarizeTitleNeedsFirstPrompt(t *testing.T) {
+	t.Setenv(session.EnvDir, t.TempDir())
+	oldLog := SessionLogDirOverride
+	defer func() { SessionLogDirOverride = oldLog }()
+	SessionLogDirOverride = t.TempDir()
+	registerFake(&userEchoStreamEngine{name: "fake-title-b", sessionID: "sess-t2"})
+
+	// 故意不传 --save-history：这条会话没有事件日志。
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-title-b", "--stream", "继续"); err != nil {
+		t.Fatalf("ask: %v", err)
+	}
+	_, _, err := runAskCmd(t, "", "--summarize-title", "sess-t2")
+	if err == nil {
+		t.Fatal("读不到首问时应拒绝归纳，而不是拿 prompt_head 凑一个「最新追问」的标题")
+	}
+	if got := session.TitleFor("sess-t2"); got != "" {
+		t.Fatalf("拒绝时不该写入任何标题，实得 %q", got)
+	}
+}
+
+// sessionRow 解析 --sessions 的 JSON 输出。
 type sessionRow struct {
 	RunID     string `json:"run_id"`
 	SessionID string `json:"session_id"`
 	PID       int    `json:"pid"`
 	Engine    string `json:"engine"`
+	Source    string `json:"source"`
+	Client    string `json:"client"`
 	State     string `json:"state"`
 	Alive     bool   `json:"alive"`
 }
@@ -44,7 +142,7 @@ func TestAskRegistersSession(t *testing.T) {
 	t.Setenv(session.EnvDir, dir)
 	registerFake(&stringEngine{name: "fake-sess-reg", text: "ok"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-sess-reg", "你好"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-sess-reg", "你好"); err != nil {
 		t.Fatalf("ask: %v", err)
 	}
 
@@ -72,7 +170,7 @@ func TestStreamAskRegistersSession(t *testing.T) {
 	t.Setenv(session.EnvDir, dir)
 	registerFake(&streamingEngine{name: "fake-sess-stream", text: "ok"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-sess-stream", "--stream", "hi"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-sess-stream", "--stream", "hi"); err != nil {
 		t.Fatalf("stream ask: %v", err)
 	}
 	rows := parseSessions(t, mustSessions(t))
@@ -91,7 +189,7 @@ func TestAskBackfillsSessionID(t *testing.T) {
 	t.Setenv(session.EnvDir, dir)
 	registerFake(&sidEngine{name: "fake-sess-sid", text: "ok", sid: "sid-from-engine"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-sess-sid", "hi"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-sess-sid", "hi"); err != nil {
 		t.Fatalf("ask: %v", err)
 	}
 	rows := parseSessions(t, mustSessions(t))
@@ -107,6 +205,47 @@ func TestAskBackfillsSessionID(t *testing.T) {
 	}
 }
 
+// 来源端与来源客户端（2026-10-12）由发起方经环境变量带进来，必须**如实落进记录**：
+// 客户端（magic-client）靠 client 这一列把自己的会话与「直接跑 CLI 的」区分开，
+// 靠 source 那一列显示手机 / 电脑标志。两个都缺，列表就会混进别人的任务。
+func TestAskRecordsSourceAndClient(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(session.EnvDir, dir)
+	t.Setenv(session.EnvSource, "mobile")
+	t.Setenv(session.EnvClient, "magic-client")
+	registerFake(&stringEngine{name: "fake-sess-src", text: "ok"})
+
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-sess-src", "hi"); err != nil {
+		t.Fatalf("ask: %v", err)
+	}
+	rows := parseSessions(t, mustSessions(t))
+	if len(rows) != 1 {
+		t.Fatalf("登记表条数 = %d want 1: %+v", len(rows), rows)
+	}
+	if rows[0].Source != session.SourceMobile || rows[0].Client != "magic-client" {
+		t.Errorf("source/client 没落进记录: %+v", rows[0])
+	}
+}
+
+// 直接跑 CLI（没人注入这两个环境变量）时，两列都该是空 —— 客户端据此把它们排除在外。
+func TestAskWithoutClientEnvLeavesSourceEmpty(t *testing.T) {
+	t.Setenv(session.EnvDir, t.TempDir())
+	t.Setenv(session.EnvSource, "")
+	t.Setenv(session.EnvClient, "")
+	registerFake(&stringEngine{name: "fake-sess-nosrc", text: "ok"})
+
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-sess-nosrc", "hi"); err != nil {
+		t.Fatalf("ask: %v", err)
+	}
+	rows := parseSessions(t, mustSessions(t))
+	if len(rows) != 1 {
+		t.Fatalf("登记表条数 = %d want 1: %+v", len(rows), rows)
+	}
+	if rows[0].Source != "" || rows[0].Client != "" {
+		t.Errorf("没人注入来源时不该有值: %+v", rows[0])
+	}
+}
+
 // sidEngine 固定返回一个 session_id 的假引擎（验回填）。
 type sidEngine struct {
 	name string
@@ -153,7 +292,7 @@ func TestStopFinishedSessionIsIdempotent(t *testing.T) {
 	t.Setenv(session.EnvDir, dir)
 	registerFake(&stringEngine{name: "fake-sess-fin", text: "ok"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-sess-fin", "hi"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-sess-fin", "hi"); err != nil {
 		t.Fatalf("ask: %v", err)
 	}
 	runID := parseSessions(t, mustSessions(t))[0].RunID