717a6bd feat(session): persist recent session order · vev

M internal/persist/persist.go +26 -1


@@ -70,13 +70,38 @@ func (p *Persister) Touch(name, cwd string, at int64) error {
70	70		}
71	71
72	72		createdAt := at
	73	+	lastUsedSeq := uint64(0)
73	74		if v, ok := p.store.Get([]byte(name)); ok {
74	75		if r, err := decodeRecordValue(name, v); err == nil {
75	76		createdAt = r.CreatedAt
	77	+	lastUsedSeq = r.LastUsedSeq
76	78		}
77	79		}
78	80
79		-	value, err := encodeRecordValue(Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: at})
	81	+	value, err := encodeRecordValue(Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: at, LastUsedSeq: lastUsedSeq})
	82	+	if err != nil {
	83	+	return err
	84	+	}
	85	+	return p.store.Set([]byte(name), value)
	86	+	}
	87	+
	88	+	// TouchMRU updates hot-path session recency without forcing an fsync.
	89	+	func (p *Persister) TouchMRU(name string, lastUsedSeq uint64) error {
	90	+	if p == nil \|\| p.store == nil {
	91	+	return nil
	92	+	}
	93	+	if name == "" {
	94	+	return errEmptyName
	95	+	}
	96	+
	97	+	r := Record{Name: name, LastUsedSeq: lastUsedSeq}
	98	+	if v, ok := p.store.Get([]byte(name)); ok {
	99	+	if decoded, err := decodeRecordValue(name, v); err == nil {
	100	+	r = decoded
	101	+	r.LastUsedSeq = lastUsedSeq
	102	+	}
	103	+	}
	104	+	value, err := encodeRecordValue(r)
80	105		if err != nil {
81	106		return err
82	107		}


@@ -70,13 +70,38 @@ func (p *Persister) Touch(name, cwd string, at int64) error {
70		}	70		}
71			71
72		createdAt := at	72		createdAt := at
			73	+	lastUsedSeq := uint64(0)
73		if v, ok := p.store.Get([]byte(name)); ok {	74		if v, ok := p.store.Get([]byte(name)); ok {
74		if r, err := decodeRecordValue(name, v); err == nil {	75		if r, err := decodeRecordValue(name, v); err == nil {
75		createdAt = r.CreatedAt	76		createdAt = r.CreatedAt
			77	+	lastUsedSeq = r.LastUsedSeq
76		}	78		}
77		}	79		}
78			80
79	-	value, err := encodeRecordValue(Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: at})	81	+	value, err := encodeRecordValue(Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: at, LastUsedSeq: lastUsedSeq})
			82	+	if err != nil {
			83	+	return err
			84	+	}
			85	+	return p.store.Set([]byte(name), value)
			86	+	}
			87	+
			88	+	// TouchMRU updates hot-path session recency without forcing an fsync.
			89	+	func (p *Persister) TouchMRU(name string, lastUsedSeq uint64) error {
			90	+	if p == nil \|\| p.store == nil {
			91	+	return nil
			92	+	}
			93	+	if name == "" {
			94	+	return errEmptyName
			95	+	}
			96	+
			97	+	r := Record{Name: name, LastUsedSeq: lastUsedSeq}
			98	+	if v, ok := p.store.Get([]byte(name)); ok {
			99	+	if decoded, err := decodeRecordValue(name, v); err == nil {
			100	+	r = decoded
			101	+	r.LastUsedSeq = lastUsedSeq
			102	+	}
			103	+	}
			104	+	value, err := encodeRecordValue(r)
80		if err != nil {	105		if err != nil {
81		return err	106		return err
82		}	107		}

M internal/persist/persist_test.go +25 -11


@@ -12,7 +12,7 @@ import (
12	12		)
13	13
14	14		func TestRecordCodecRoundTrip(t *testing.T) {
15		-	r := Record{Name: "work", Cwd: "/tmp/project", CreatedAt: 11, UpdatedAt: 22}
	15	+	r := Record{Name: "work", Cwd: "/tmp/project", CreatedAt: 11, UpdatedAt: 22, LastUsedSeq: 33}
16	16		value, err := encodeRecordValue(r)
17	17		require.NoError(t, err)
18	18

@@ -21,6 +21,16 @@ func TestRecordCodecRoundTrip(t *testing.T) {
21	21		require.Equal(t, r, got)
22	22		}
23	23
	24	+	func TestRecordCodecOldRecordDefaultsLastUsed(t *testing.T) {
	25	+	old := []byte{0, 0, 0, 4, '/', 't', 'm', 'p'}
	26	+	old = append(old, 0, 0, 0, 0, 0, 0, 0, 11)
	27	+	old = append(old, 0, 0, 0, 0, 0, 0, 0, 22)
	28	+
	29	+	got, err := decodeRecordValue("work", old)
	30	+	require.NoError(t, err)
	31	+	require.Equal(t, Record{Name: "work", Cwd: "/tmp", CreatedAt: 11, UpdatedAt: 22}, got)
	32	+	}
	33	+
24	34		func TestRecordCodecRejectsMalformedData(t *testing.T) {
25	35		_, err := encodeRecordValue(Record{Cwd: "/tmp"})
26	36		require.ErrorIs(t, err, errEmptyName)

@@ -31,7 +41,6 @@ func TestRecordCodecRejectsMalformedData(t *testing.T) {
31	41		{0, 0, 0, 5, 'a'},
32	42		{0, 0, 0, 1, 'a', 0},
33	43		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
34		-	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
35	44		}
36	45		for _, value := range badValues {
37	46		_, err := decodeRecordValue("name", value)

@@ -67,26 +76,27 @@ func TestPersisterSaveTouchDeleteLoadAll(t *testing.T) {
67	76		p, err := Open(dir)
68	77		require.NoError(t, err)
69	78
70		-	require.NoError(t, p.Save(Record{Name: "b", Cwd: "/b", CreatedAt: 10, UpdatedAt: 10}))
71		-	require.NoError(t, p.Save(Record{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20}))
	79	+	require.NoError(t, p.Save(Record{Name: "b", Cwd: "/b", CreatedAt: 10, UpdatedAt: 10, LastUsedSeq: 40}))
	80	+	require.NoError(t, p.Save(Record{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20, LastUsedSeq: 50}))
72	81		require.NoError(t, p.Touch("b", "/b/next", 30))
	82	+	require.NoError(t, p.TouchMRU("b", 60))
73	83
74	84		records, err := p.LoadAll()
75	85		require.NoError(t, err)
76	86		require.Equal(t, []Record{
77		-	{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20},
78		-	{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30},
	87	+	{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20, LastUsedSeq: 50},
	88	+	{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30, LastUsedSeq: 60},
79	89		}, records)
80	90
81	91		require.NoError(t, p.Delete("a"))
82	92		records, err = p.LoadAll()
83	93		require.NoError(t, err)
84		-	require.Equal(t, []Record{{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30}}, records)
	94	+	require.Equal(t, []Record{{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30, LastUsedSeq: 60}}, records)
85	95		require.NoError(t, p.Close())
86	96		}
87	97
88	98		func TestDecodeAllSkipsMalformedRecords(t *testing.T) {
89		-	good, err := encodeRecordValue(Record{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2})
	99	+	good, err := encodeRecordValue(Record{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3})
90	100		require.NoError(t, err)
91	101
92	102		records, err := decodeAll(map[string][]byte{

@@ -94,19 +104,19 @@ func TestDecodeAllSkipsMalformedRecords(t *testing.T) {
94	104		"good": good,
95	105		})
96	106		require.NoError(t, err)
97		-	require.Equal(t, []Record{{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2}}, records)
	107	+	require.Equal(t, []Record{{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3}}, records)
98	108		}
99	109
100	110		func TestLoadReadOnlyUsesReplay(t *testing.T) {
101	111		dir := t.TempDir()
102	112		p, err := Open(dir)
103	113		require.NoError(t, err)
104		-	require.NoError(t, p.Save(Record{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2}))
	114	+	require.NoError(t, p.Save(Record{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3}))
105	115		require.NoError(t, p.Close())
106	116
107	117		records, err := LoadReadOnly(dir)
108	118		require.NoError(t, err)
109		-	require.Equal(t, []Record{{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2}}, records)
	119	+	require.Equal(t, []Record{{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3}}, records)
110	120
111	121		// Missing stores replay as empty rather than creating the WAL.
112	122		missing := filepath.Join(t.TempDir(), "missing")

@@ -127,6 +137,10 @@ func TestSyncBehavior(t *testing.T) {
127	137		require.Equal(t, 2, state.sets)
128	138		require.Equal(t, 1, state.syncs)
129	139
	140	+	require.NoError(t, p.TouchMRU("work", 3))
	141	+	require.Equal(t, 3, state.sets)
	142	+	require.Equal(t, 1, state.syncs)
	143	+
130	144		require.NoError(t, p.Delete("work"))
131	145		require.Equal(t, 1, state.deletes)
132	146		require.Equal(t, 2, state.syncs)

 )
 func TestRecordCodecRoundTrip(t *testing.T) {
-	r := Record{Name: "work", Cwd: "/tmp/project", CreatedAt: 11, UpdatedAt: 22}
+	r := Record{Name: "work", Cwd: "/tmp/project", CreatedAt: 11, UpdatedAt: 22, LastUsedSeq: 33}
 	value, err := encodeRecordValue(r)
 	require.NoError(t, err)
 	require.Equal(t, r, got)
 }
+func TestRecordCodecOldRecordDefaultsLastUsed(t *testing.T) {
+	old := []byte{0, 0, 0, 4, '/', 't', 'm', 'p'}
+	old = append(old, 0, 0, 0, 0, 0, 0, 0, 11)
+	old = append(old, 0, 0, 0, 0, 0, 0, 0, 22)
+	got, err := decodeRecordValue("work", old)
+	require.NoError(t, err)
+	require.Equal(t, Record{Name: "work", Cwd: "/tmp", CreatedAt: 11, UpdatedAt: 22}, got)
+}
 func TestRecordCodecRejectsMalformedData(t *testing.T) {
 	_, err := encodeRecordValue(Record{Cwd: "/tmp"})
 	require.ErrorIs(t, err, errEmptyName)
 		{0, 0, 0, 5, 'a'},
 		{0, 0, 0, 1, 'a', 0},
 		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-		{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 	}
 	for _, value := range badValues {
 		_, err := decodeRecordValue("name", value)
 	p, err := Open(dir)
 	require.NoError(t, err)
-	require.NoError(t, p.Save(Record{Name: "b", Cwd: "/b", CreatedAt: 10, UpdatedAt: 10}))
+	require.NoError(t, p.Save(Record{Name: "b", Cwd: "/b", CreatedAt: 10, UpdatedAt: 10, LastUsedSeq: 40}))
-	require.NoError(t, p.Save(Record{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20}))
+	require.NoError(t, p.Save(Record{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20, LastUsedSeq: 50}))
 	require.NoError(t, p.Touch("b", "/b/next", 30))
+	require.NoError(t, p.TouchMRU("b", 60))
 	records, err := p.LoadAll()
 	require.NoError(t, err)
 	require.Equal(t, []Record{
-		{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20},
+		{Name: "a", Cwd: "/a", CreatedAt: 20, UpdatedAt: 20, LastUsedSeq: 50},
-		{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30},
+		{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30, LastUsedSeq: 60},
 	}, records)
 	require.NoError(t, p.Delete("a"))
 	records, err = p.LoadAll()
 	require.NoError(t, err)
-	require.Equal(t, []Record{{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30}}, records)
+	require.Equal(t, []Record{{Name: "b", Cwd: "/b/next", CreatedAt: 10, UpdatedAt: 30, LastUsedSeq: 60}}, records)
 	require.NoError(t, p.Close())
 }
 func TestDecodeAllSkipsMalformedRecords(t *testing.T) {
-	good, err := encodeRecordValue(Record{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2})
+	good, err := encodeRecordValue(Record{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3})
 	require.NoError(t, err)
 	records, err := decodeAll(map[string][]byte{
 		"good": good,
 	})
 	require.NoError(t, err)
-	require.Equal(t, []Record{{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2}}, records)
+	require.Equal(t, []Record{{Name: "good", Cwd: "/ok", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3}}, records)
 }
 func TestLoadReadOnlyUsesReplay(t *testing.T) {
 	dir := t.TempDir()
 	p, err := Open(dir)
 	require.NoError(t, err)
-	require.NoError(t, p.Save(Record{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2}))
+	require.NoError(t, p.Save(Record{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3}))
 	require.NoError(t, p.Close())
 	records, err := LoadReadOnly(dir)
 	require.NoError(t, err)
-	require.Equal(t, []Record{{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2}}, records)
+	require.Equal(t, []Record{{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 2, LastUsedSeq: 3}}, records)
 	// Missing stores replay as empty rather than creating the WAL.
 	missing := filepath.Join(t.TempDir(), "missing")
 	require.Equal(t, 2, state.sets)
 	require.Equal(t, 1, state.syncs)
+	require.NoError(t, p.TouchMRU("work", 3))
+	require.Equal(t, 3, state.sets)
+	require.Equal(t, 1, state.syncs)
 	require.NoError(t, p.Delete("work"))
 	require.Equal(t, 1, state.deletes)
 	require.Equal(t, 2, state.syncs)

M internal/persist/record.go +14 -8


@@ -9,10 +9,11 @@ import (
9	9
10	10		// Record is the persisted metadata for a named session.
11	11		type Record struct {
12		-	Name string
13		-	Cwd string
14		-	CreatedAt int64
15		-	UpdatedAt int64
	12	+	Name string
	13	+	Cwd string
	14	+	CreatedAt int64
	15	+	UpdatedAt int64
	16	+	LastUsedSeq uint64
16	17		}
17	18
18	19		var (

@@ -28,12 +29,13 @@ func encodeRecordValue(r Record) ([]byte, error) {
28	29		return nil, fmt.Errorf("persist: cwd too large")
29	30		}
30	31
31		-	buf := make([]byte, 4+len(r.Cwd)+8+8)
	32	+	buf := make([]byte, 4+len(r.Cwd)+8+8+8)
32	33		binary.BigEndian.PutUint32(buf[:4], uint32(len(r.Cwd)))
33	34		copy(buf[4:], r.Cwd)
34	35		off := 4 + len(r.Cwd)
35	36		binary.BigEndian.PutUint64(buf[off:off+8], uint64(r.CreatedAt))
36	37		binary.BigEndian.PutUint64(buf[off+8:off+16], uint64(r.UpdatedAt))
	38	+	binary.BigEndian.PutUint64(buf[off+16:off+24], r.LastUsedSeq)
37	39		return buf, nil
38	40		}
39	41

@@ -50,14 +52,18 @@ func decodeRecordValue(name string, value []byte) (Record, error) {
50	52		return Record{}, errMalformedRecord
51	53		}
52	54		cwdLen := int(cwdLen32)
53		-	if len(value) != 4+cwdLen+8+8 {
	55	+	if len(value) != 4+cwdLen+8+8 && len(value) != 4+cwdLen+8+8+8 {
54	56		return Record{}, errMalformedRecord
55	57		}
56	58		off := 4 + cwdLen
57		-	return Record{
	59	+	r := Record{
58	60		Name: name,
59	61		Cwd: string(value[4:off]),
60	62		CreatedAt: int64(binary.BigEndian.Uint64(value[off : off+8])),
61	63		UpdatedAt: int64(binary.BigEndian.Uint64(value[off+8 : off+16])),
62		-	}, nil
	64	+	}
	65	+	if len(value) == 4+cwdLen+8+8+8 {
	66	+	r.LastUsedSeq = binary.BigEndian.Uint64(value[off+16 : off+24])
	67	+	}
	68	+	return r, nil
63	69		}

 // Record is the persisted metadata for a named session.
 type Record struct {
-	Name      string
+	Name        string
-	Cwd       string
+	Cwd         string
-	CreatedAt int64
+	CreatedAt   int64
-	UpdatedAt int64
+	UpdatedAt   int64
+	LastUsedSeq uint64
 }
 var (
 		return nil, fmt.Errorf("persist: cwd too large")
 	}
-	buf := make([]byte, 4+len(r.Cwd)+8+8)
+	buf := make([]byte, 4+len(r.Cwd)+8+8+8)
 	binary.BigEndian.PutUint32(buf[:4], uint32(len(r.Cwd)))
 	copy(buf[4:], r.Cwd)
 	off := 4 + len(r.Cwd)
 	binary.BigEndian.PutUint64(buf[off:off+8], uint64(r.CreatedAt))
 	binary.BigEndian.PutUint64(buf[off+8:off+16], uint64(r.UpdatedAt))
+	binary.BigEndian.PutUint64(buf[off+16:off+24], r.LastUsedSeq)
 	return buf, nil
 }
 		return Record{}, errMalformedRecord
 	}
 	cwdLen := int(cwdLen32)
-	if len(value) != 4+cwdLen+8+8 {
+	if len(value) != 4+cwdLen+8+8 && len(value) != 4+cwdLen+8+8+8 {
 		return Record{}, errMalformedRecord
 	}
 	off := 4 + cwdLen
-	return Record{
+	r := Record{
 		Name:      name,
 		Cwd:       string(value[4:off]),
 		CreatedAt: int64(binary.BigEndian.Uint64(value[off : off+8])),
 		UpdatedAt: int64(binary.BigEndian.Uint64(value[off+8 : off+16])),
-	}, nil
+	}
+	if len(value) == 4+cwdLen+8+8+8 {
+		r.LastUsedSeq = binary.BigEndian.Uint64(value[off+16 : off+24])
+	}
+	return r, nil
 }

M internal/usecase/daemon/daemon.go +11 -5


@@ -136,10 +136,11 @@ type parkedAttachment struct {
136	136		// session is a single multiplexed session. It owns one or more full-screen
137	137
138	138		type stoppedSession struct {
139		-	name string
140		-	cwd string
141		-	createdAt int64
142		-	purging bool
	139	+	name string
	140	+	cwd string
	141	+	createdAt int64
	142	+	lastUsedSeq uint64
	143	+	purging bool
143	144		}
144	145
145	146		type Option func(*Daemon)

@@ -221,9 +222,14 @@ func New(ptys ports.PTYFactory, clock ports.Clock, log *slog.Logger, opts ...Opt
221	222		if records, err := d.persist.LoadAll(); err != nil {
222	223		d.log.Warn("loading persisted sessions failed", "err", err)
223	224		} else {
	225	+	var maxSeq uint64
224	226		for _, r := range records {
225		-	d.stopped[r.Name] = stoppedSession{name: r.Name, cwd: r.Cwd, createdAt: r.CreatedAt}
	227	+	d.stopped[r.Name] = stoppedSession{name: r.Name, cwd: r.Cwd, createdAt: r.CreatedAt, lastUsedSeq: r.LastUsedSeq}
	228	+	if r.LastUsedSeq > maxSeq {
	229	+	maxSeq = r.LastUsedSeq
	230	+	}
226	231		}
	232	+	d.mruSeq.Store(maxSeq)
227	233		}
228	234		return d
229	235		}

 // session is a single multiplexed session. It owns one or more full-screen
 type stoppedSession struct {
-	name      string
+	name        string
-	cwd       string
+	cwd         string
-	createdAt int64
+	createdAt   int64
-	purging   bool
+	lastUsedSeq uint64
+	purging     bool
 }
 type Option func(*Daemon)
 	if records, err := d.persist.LoadAll(); err != nil {
 		d.log.Warn("loading persisted sessions failed", "err", err)
 	} else {
+		var maxSeq uint64
 		for _, r := range records {
-			d.stopped[r.Name] = stoppedSession{name: r.Name, cwd: r.Cwd, createdAt: r.CreatedAt}
+			d.stopped[r.Name] = stoppedSession{name: r.Name, cwd: r.Cwd, createdAt: r.CreatedAt, lastUsedSeq: r.LastUsedSeq}
+			if r.LastUsedSeq > maxSeq {
+				maxSeq = r.LastUsedSeq
+			}
 		}
+		d.mruSeq.Store(maxSeq)
 	}
 	return d
 }

M internal/usecase/daemon/session.go +31 -5


@@ -93,13 +93,27 @@ func (d Daemon) touchMRU(sess session) {
93	93		return
94	94		}
95	95		seq := d.mruSeq.Add(1)
	96	+	updated := false
96	97		for {
97	98		old := sess.mruAt.Load()
98	99		if old >= seq {
99	100		return
100	101		}
101	102		if sess.mruAt.CompareAndSwap(old, seq) {
102		-	return
	103	+	updated = true
	104	+	break
	105	+	}
	106	+	}
	107	+	if !updated {
	108	+	return
	109	+	}
	110	+	sess.mu.Lock()
	111	+	name := sess.name
	112	+	ephemeral := sess.ephemeral
	113	+	sess.mu.Unlock()
	114	+	if !ephemeral && d.persist != nil {
	115	+	if err := d.persist.TouchMRU(name, seq); err != nil {
	116	+	d.log.Warn("touching persisted session recency failed", "err", err, "session", name)
103	117		}
104	118		}
105	119		}

@@ -119,6 +133,12 @@ func (d *Daemon) createSessionLocked(name string, ephemeral bool, cwd string, sz
119	133		tb := newTab(pty, tbSize)
120	134		sctx, cancel := context.WithCancel(d.serveCtx)
121	135		tb.ctx, tb.cancel = context.WithCancel(sctx)
	136	+	lastUsedSeq := uint64(0)
	137	+	if !ephemeral {
	138	+	if stopped, ok := d.stopped[name]; ok {
	139	+	lastUsedSeq = stopped.lastUsedSeq
	140	+	}
	141	+	}
122	142		sess := &session{
123	143		id: id,
124	144		name: name,

@@ -129,8 +149,11 @@ func (d *Daemon) createSessionLocked(name string, ephemeral bool, cwd string, sz
129	149		cwd: cwd,
130	150		createdAt: createdAt,
131	151		}
	152	+	if lastUsedSeq > 0 {
	153	+	sess.mruAt.Store(lastUsedSeq)
	154	+	}
132	155		if !ephemeral {
133		-	if err := d.persist.Save(persist.Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: createdAt}); err != nil {
	156	+	if err := d.persist.Save(persist.Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: createdAt, LastUsedSeq: lastUsedSeq}); err != nil {
134	157		_ = pty.Close()
135	158		cancel()
136	159		return nil, err

@@ -138,7 +161,9 @@ func (d *Daemon) createSessionLocked(name string, ephemeral bool, cwd string, sz
138	161		delete(d.stopped, name)
139	162		}
140	163		d.sessions[id] = sess
141		-	d.touchMRU(sess)
	164	+	if lastUsedSeq == 0 {
	165	+	d.touchMRU(sess)
	166	+	}
142	167		d.log.Info("session created", "session", name, "id", id, "ephemeral", ephemeral)
143	168		d.log.Info("tab created", "session", name, "tab", 0)
144	169		d.startTabGoroutines(sess, tb)

@@ -374,8 +399,9 @@ func (d Daemon) renameSession(sess session, name string) error {
374	399		createdAt = time.Now().UnixNano()
375	400		sess.createdAt = createdAt
376	401		}
	402	+	lastUsedSeq := sess.mruAt.Load()
377	403		if wasEphemeral \|\| oldName != name {
378		-	if err := d.persist.Save(persist.Record{Name: name, Cwd: sess.cwd, CreatedAt: createdAt, UpdatedAt: time.Now().UnixNano()}); err != nil {
	404	+	if err := d.persist.Save(persist.Record{Name: name, Cwd: sess.cwd, CreatedAt: createdAt, UpdatedAt: time.Now().UnixNano(), LastUsedSeq: lastUsedSeq}); err != nil {
379	405		return err
380	406		}
381	407		}

@@ -464,7 +490,7 @@ func (d Daemon) killSession(sess session, reason uint8, purge bool) error {
464	490		ephemeral := sess.ephemeral
465	491		sess.mu.Unlock()
466	492		if !ephemeral {
467		-	stopped := stoppedSession{name: stoppedName, cwd: stoppedCwd, createdAt: createdAt, purging: purge}
	493	+	stopped := stoppedSession{name: stoppedName, cwd: stoppedCwd, createdAt: createdAt, lastUsedSeq: sess.mruAt.Load(), purging: purge}
468	494		d.stopped[stoppedName] = stopped
469	495		}
470	496		empty := len(d.sessions) == 0

 		return
 	}
 	seq := d.mruSeq.Add(1)
+	updated := false
 	for {
 		old := sess.mruAt.Load()
 		if old >= seq {
 			return
 		}
 		if sess.mruAt.CompareAndSwap(old, seq) {
-			return
+			updated = true
+			break
+		}
+	}
+	if !updated {
+		return
+	}
+	sess.mu.Lock()
+	name := sess.name
+	ephemeral := sess.ephemeral
+	sess.mu.Unlock()
+	if !ephemeral && d.persist != nil {
+		if err := d.persist.TouchMRU(name, seq); err != nil {
+			d.log.Warn("touching persisted session recency failed", "err", err, "session", name)
 		}
 	}
 }
 	tb := newTab(pty, tbSize)
 	sctx, cancel := context.WithCancel(d.serveCtx)
 	tb.ctx, tb.cancel = context.WithCancel(sctx)
+	lastUsedSeq := uint64(0)
+	if !ephemeral {
+		if stopped, ok := d.stopped[name]; ok {
+			lastUsedSeq = stopped.lastUsedSeq
+		}
+	}
 	sess := &session{
 		id:        id,
 		name:      name,
 		cwd:       cwd,
 		createdAt: createdAt,
 	}
+	if lastUsedSeq > 0 {
+		sess.mruAt.Store(lastUsedSeq)
+	}
 	if !ephemeral {
-		if err := d.persist.Save(persist.Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: createdAt}); err != nil {
+		if err := d.persist.Save(persist.Record{Name: name, Cwd: cwd, CreatedAt: createdAt, UpdatedAt: createdAt, LastUsedSeq: lastUsedSeq}); err != nil {
 			_ = pty.Close()
 			cancel()
 			return nil, err
 		delete(d.stopped, name)
 	}
 	d.sessions[id] = sess
-	d.touchMRU(sess)
+	if lastUsedSeq == 0 {
+		d.touchMRU(sess)
+	}
 	d.log.Info("session created", "session", name, "id", id, "ephemeral", ephemeral)
 	d.log.Info("tab created", "session", name, "tab", 0)
 	d.startTabGoroutines(sess, tb)
 		createdAt = time.Now().UnixNano()
 		sess.createdAt = createdAt
 	}
+	lastUsedSeq := sess.mruAt.Load()
 	if wasEphemeral || oldName != name {
-		if err := d.persist.Save(persist.Record{Name: name, Cwd: sess.cwd, CreatedAt: createdAt, UpdatedAt: time.Now().UnixNano()}); err != nil {
+		if err := d.persist.Save(persist.Record{Name: name, Cwd: sess.cwd, CreatedAt: createdAt, UpdatedAt: time.Now().UnixNano(), LastUsedSeq: lastUsedSeq}); err != nil {
 			return err
 		}
 	}
 	ephemeral := sess.ephemeral
 	sess.mu.Unlock()
 	if !ephemeral {
-		stopped := stoppedSession{name: stoppedName, cwd: stoppedCwd, createdAt: createdAt, purging: purge}
+		stopped := stoppedSession{name: stoppedName, cwd: stoppedCwd, createdAt: createdAt, lastUsedSeq: sess.mruAt.Load(), purging: purge}
 		d.stopped[stoppedName] = stopped
 	}
 	empty := len(d.sessions) == 0

M internal/usecase/daemon/session_test.go +69 -2


@@ -648,16 +648,50 @@ func (s *mockStoreState) has(name string) bool {
648	648		return ok
649	649		}
650	650
	651	+	func (s mockStoreState) record(t testing.T, name string) persist.Record {
	652	+	t.Helper()
	653	+	s.mu.Lock()
	654	+	defer s.mu.Unlock()
	655	+	records, err := persist.New(newStaticStore(s.data)).LoadAll()
	656	+	require.NoError(t, err)
	657	+	for _, r := range records {
	658	+	if r.Name == name {
	659	+	return r
	660	+	}
	661	+	}
	662	+	t.Fatalf("record %q not found", name)
	663	+	return persist.Record{}
	664	+	}
	665	+
	666	+	type newStaticStore map[string][]byte
	667	+
	668	+	func (s newStaticStore) Get(key []byte) ([]byte, bool) {
	669	+	v, ok := s[string(key)]
	670	+	return append([]byte(nil), v...), ok
	671	+	}
	672	+	func (s newStaticStore) Set(_, _ []byte) error { return nil }
	673	+	func (s newStaticStore) Delete(_ []byte) error { return nil }
	674	+	func (s newStaticStore) Range(fn func(k, v []byte) bool) {
	675	+	for k, v := range s {
	676	+	if !fn([]byte(k), append([]byte(nil), v...)) {
	677	+	return
	678	+	}
	679	+	}
	680	+	}
	681	+	func (s newStaticStore) Sync() error { return nil }
	682	+	func (s newStaticStore) Close() error { return nil }
	683	+
651	684		func TestDaemonLoadsPersistedSessionsAsStopped(t *testing.T) {
652	685		store, _ := newMockStore(t)
653	686		seed := New(nil, stubClock{}, slog.New(slog.NewTextHandler(io.Discard, nil)), WithStore(store))
654		-	require.NoError(t, seed.persist.Save(persist.Record{Name: "work", Cwd: "/tmp/work", CreatedAt: 7, UpdatedAt: 8}))
	687	+	require.NoError(t, seed.persist.Save(persist.Record{Name: "work", Cwd: "/tmp/work", CreatedAt: 7, UpdatedAt: 8, LastUsedSeq: 9}))
655	688
656	689		d := New(nil, stubClock{}, slog.New(slog.NewTextHandler(io.Discard, nil)), WithStore(store))
657	690		d.mu.Lock()
658	691		stopped := d.stopped["work"]
659	692		d.mu.Unlock()
660		-	require.Equal(t, stoppedSession{name: "work", cwd: "/tmp/work", createdAt: 7}, stopped)
	693	+	require.Equal(t, stoppedSession{name: "work", cwd: "/tmp/work", createdAt: 7, lastUsedSeq: 9}, stopped)
	694	+	require.Equal(t, uint64(9), d.mruSeq.Load())
661	695		}
662	696
663	697		func TestTouchMRUConcurrentUpdatesRemainMonotonic(t *testing.T) {

@@ -709,6 +743,39 @@ func TestTouchMRUConcurrentUpdatesRemainMonotonic(t *testing.T) {
709	743		require.Equal(t, d.mruSeq.Load(), sess.mruAt.Load())
710	744		}
711	745
	746	+	func TestTouchMRUPersistsNamedButNotEphemeral(t *testing.T) {
	747	+	store, state := newMockStore(t)
	748	+	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
	749	+	WithStore(store)(d)
	750	+	named := &session{name: "work", tabs: []*tab{{}}, createdAt: 1}
	751	+	require.NoError(t, d.persist.Save(persist.Record{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 1}))
	752	+
	753	+	d.touchMRU(named)
	754	+	require.Equal(t, named.mruAt.Load(), state.record(t, "work").LastUsedSeq)
	755	+	setsAfterNamed := state.sets
	756	+
	757	+	ephemeral := &session{name: "0", ephemeral: true, tabs: []*tab{{}}}
	758	+	d.touchMRU(ephemeral)
	759	+	require.False(t, state.has("0"))
	760	+	require.Equal(t, setsAfterNamed, state.sets)
	761	+	}
	762	+
	763	+	func TestCreateSessionSeedsMRUFromStopped(t *testing.T) {
	764	+	sz := domain.Size{Cols: 80, Rows: 24}
	765	+	p, release := newBlockingPTY(t)
	766	+	defer release()
	767	+	store, state := newMockStore(t)
	768	+	d := newTestDaemon(t, newFactory(t, p), stubClock{})
	769	+	WithStore(store)(d)
	770	+	d.stopped["work"] = stoppedSession{name: "work", cwd: "/tmp/work", createdAt: 1, lastUsedSeq: 42}
	771	+	d.mruSeq.Store(42)
	772	+
	773	+	sess, err := d.createSessionLocked("work", false, "/tmp/work", sz)
	774	+	require.NoError(t, err)
	775	+	require.Equal(t, uint64(42), sess.mruAt.Load())
	776	+	require.Equal(t, uint64(42), state.record(t, "work").LastUsedSeq)
	777	+	}
	778	+
712	779		func TestCreateRenameKillPersistenceLifecycle(t *testing.T) {
713	780		sz := domain.Size{Cols: 80, Rows: 24}
714	781		p, release := newBlockingPTY(t)


@@ -648,16 +648,50 @@ func (s *mockStoreState) has(name string) bool {
648		return ok	648		return ok
649		}	649		}
650			650
			651	+	func (s mockStoreState) record(t testing.T, name string) persist.Record {
			652	+	t.Helper()
			653	+	s.mu.Lock()
			654	+	defer s.mu.Unlock()
			655	+	records, err := persist.New(newStaticStore(s.data)).LoadAll()
			656	+	require.NoError(t, err)
			657	+	for _, r := range records {
			658	+	if r.Name == name {
			659	+	return r
			660	+	}
			661	+	}
			662	+	t.Fatalf("record %q not found", name)
			663	+	return persist.Record{}
			664	+	}
			665	+
			666	+	type newStaticStore map[string][]byte
			667	+
			668	+	func (s newStaticStore) Get(key []byte) ([]byte, bool) {
			669	+	v, ok := s[string(key)]
			670	+	return append([]byte(nil), v...), ok
			671	+	}
			672	+	func (s newStaticStore) Set(_, _ []byte) error { return nil }
			673	+	func (s newStaticStore) Delete(_ []byte) error { return nil }
			674	+	func (s newStaticStore) Range(fn func(k, v []byte) bool) {
			675	+	for k, v := range s {
			676	+	if !fn([]byte(k), append([]byte(nil), v...)) {
			677	+	return
			678	+	}
			679	+	}
			680	+	}
			681	+	func (s newStaticStore) Sync() error { return nil }
			682	+	func (s newStaticStore) Close() error { return nil }
			683	+
651		func TestDaemonLoadsPersistedSessionsAsStopped(t *testing.T) {	684		func TestDaemonLoadsPersistedSessionsAsStopped(t *testing.T) {
652		store, _ := newMockStore(t)	685		store, _ := newMockStore(t)
653		seed := New(nil, stubClock{}, slog.New(slog.NewTextHandler(io.Discard, nil)), WithStore(store))	686		seed := New(nil, stubClock{}, slog.New(slog.NewTextHandler(io.Discard, nil)), WithStore(store))
654	-	require.NoError(t, seed.persist.Save(persist.Record{Name: "work", Cwd: "/tmp/work", CreatedAt: 7, UpdatedAt: 8}))	687	+	require.NoError(t, seed.persist.Save(persist.Record{Name: "work", Cwd: "/tmp/work", CreatedAt: 7, UpdatedAt: 8, LastUsedSeq: 9}))
655			688
656		d := New(nil, stubClock{}, slog.New(slog.NewTextHandler(io.Discard, nil)), WithStore(store))	689		d := New(nil, stubClock{}, slog.New(slog.NewTextHandler(io.Discard, nil)), WithStore(store))
657		d.mu.Lock()	690		d.mu.Lock()
658		stopped := d.stopped["work"]	691		stopped := d.stopped["work"]
659		d.mu.Unlock()	692		d.mu.Unlock()
660	-	require.Equal(t, stoppedSession{name: "work", cwd: "/tmp/work", createdAt: 7}, stopped)	693	+	require.Equal(t, stoppedSession{name: "work", cwd: "/tmp/work", createdAt: 7, lastUsedSeq: 9}, stopped)
			694	+	require.Equal(t, uint64(9), d.mruSeq.Load())
661		}	695		}
662			696
663		func TestTouchMRUConcurrentUpdatesRemainMonotonic(t *testing.T) {	697		func TestTouchMRUConcurrentUpdatesRemainMonotonic(t *testing.T) {

@@ -709,6 +743,39 @@ func TestTouchMRUConcurrentUpdatesRemainMonotonic(t *testing.T) {
709		require.Equal(t, d.mruSeq.Load(), sess.mruAt.Load())	743		require.Equal(t, d.mruSeq.Load(), sess.mruAt.Load())
710		}	744		}
711			745
			746	+	func TestTouchMRUPersistsNamedButNotEphemeral(t *testing.T) {
			747	+	store, state := newMockStore(t)
			748	+	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
			749	+	WithStore(store)(d)
			750	+	named := &session{name: "work", tabs: []*tab{{}}, createdAt: 1}
			751	+	require.NoError(t, d.persist.Save(persist.Record{Name: "work", Cwd: "/work", CreatedAt: 1, UpdatedAt: 1}))
			752	+
			753	+	d.touchMRU(named)
			754	+	require.Equal(t, named.mruAt.Load(), state.record(t, "work").LastUsedSeq)
			755	+	setsAfterNamed := state.sets
			756	+
			757	+	ephemeral := &session{name: "0", ephemeral: true, tabs: []*tab{{}}}
			758	+	d.touchMRU(ephemeral)
			759	+	require.False(t, state.has("0"))
			760	+	require.Equal(t, setsAfterNamed, state.sets)
			761	+	}
			762	+
			763	+	func TestCreateSessionSeedsMRUFromStopped(t *testing.T) {
			764	+	sz := domain.Size{Cols: 80, Rows: 24}
			765	+	p, release := newBlockingPTY(t)
			766	+	defer release()
			767	+	store, state := newMockStore(t)
			768	+	d := newTestDaemon(t, newFactory(t, p), stubClock{})
			769	+	WithStore(store)(d)
			770	+	d.stopped["work"] = stoppedSession{name: "work", cwd: "/tmp/work", createdAt: 1, lastUsedSeq: 42}
			771	+	d.mruSeq.Store(42)
			772	+
			773	+	sess, err := d.createSessionLocked("work", false, "/tmp/work", sz)
			774	+	require.NoError(t, err)
			775	+	require.Equal(t, uint64(42), sess.mruAt.Load())
			776	+	require.Equal(t, uint64(42), state.record(t, "work").LastUsedSeq)
			777	+	}
			778	+
712		func TestCreateRenameKillPersistenceLifecycle(t *testing.T) {	779		func TestCreateRenameKillPersistenceLifecycle(t *testing.T) {
713		sz := domain.Size{Cols: 80, Rows: 24}	780		sz := domain.Size{Cols: 80, Rows: 24}
714		p, release := newBlockingPTY(t)	781		p, release := newBlockingPTY(t)

M internal/usecase/daemon/status_test.go +23 -0


@@ -321,6 +321,29 @@ func TestBarStateForMRUZeroTimesUseDeterministicNameOrder(t *testing.T) {
321	321		require.Equal(t, []string{"alpha", "bravo", "charlie"}, []string{state.mru[0].name, state.mru[1].name, state.mru[2].name})
322	322		}
323	323
	324	+	func TestBarStateForMRURestoredStoppedSessionsUsePersistedOrder(t *testing.T) {
	325	+	sz := domain.Size{Cols: 80, Rows: 24}
	326	+	p1, releasePTY1 := newBlockingPTY(t)
	327	+	defer releasePTY1()
	328	+	p2, releasePTY2 := newBlockingPTY(t)
	329	+	defer releasePTY2()
	330	+	d := newTestDaemon(t, newFactorySeq(t, p1, p2), stubClock{})
	331	+	d.stopped["alpha"] = stoppedSession{name: "alpha", cwd: "/tmp/alpha", createdAt: 1, lastUsedSeq: 30}
	332	+	d.stopped["zeta"] = stoppedSession{name: "zeta", cwd: "/tmp/zeta", createdAt: 1, lastUsedSeq: 20}
	333	+	d.mruSeq.Store(30)
	334	+	cur := &session{id: "cur", name: "current", tabs: []*tab{{}}}
	335	+	d.sessions[cur.id] = cur
	336	+
	337	+	_, err := d.createSessionLocked("zeta", false, "/tmp/zeta", sz)
	338	+	require.NoError(t, err)
	339	+	_, err = d.createSessionLocked("alpha", false, "/tmp/alpha", sz)
	340	+	require.NoError(t, err)
	341	+
	342	+	state := d.barStateFor(cur, "")
	343	+	require.GreaterOrEqual(t, len(state.mru), 2)
	344	+	require.Equal(t, []string{"alpha", "zeta"}, []string{state.mru[0].name, state.mru[1].name})
	345	+	}
	346	+
324	347		func TestStatusBarRendersMRUNamesEphemeralAndInlineBell(t *testing.T) {
325	348		state := barState{
326	349		status: statusSnapshot{session: "cur"},


@@ -321,6 +321,29 @@ func TestBarStateForMRUZeroTimesUseDeterministicNameOrder(t *testing.T) {
321	require.Equal(t, []string{"alpha", "bravo", "charlie"}, []string{state.mru[0].name, state.mru[1].name, state.mru[2].name})	321		require.Equal(t, []string{"alpha", "bravo", "charlie"}, []string{state.mru[0].name, state.mru[1].name, state.mru[2].name})
322	}	322		}
323		323
		324	+	func TestBarStateForMRURestoredStoppedSessionsUsePersistedOrder(t *testing.T) {
		325	+	sz := domain.Size{Cols: 80, Rows: 24}
		326	+	p1, releasePTY1 := newBlockingPTY(t)
		327	+	defer releasePTY1()
		328	+	p2, releasePTY2 := newBlockingPTY(t)
		329	+	defer releasePTY2()
		330	+	d := newTestDaemon(t, newFactorySeq(t, p1, p2), stubClock{})
		331	+	d.stopped["alpha"] = stoppedSession{name: "alpha", cwd: "/tmp/alpha", createdAt: 1, lastUsedSeq: 30}
		332	+	d.stopped["zeta"] = stoppedSession{name: "zeta", cwd: "/tmp/zeta", createdAt: 1, lastUsedSeq: 20}
		333	+	d.mruSeq.Store(30)
		334	+	cur := &session{id: "cur", name: "current", tabs: []*tab{{}}}
		335	+	d.sessions[cur.id] = cur
		336	+
		337	+	_, err := d.createSessionLocked("zeta", false, "/tmp/zeta", sz)
		338	+	require.NoError(t, err)
		339	+	_, err = d.createSessionLocked("alpha", false, "/tmp/alpha", sz)
		340	+	require.NoError(t, err)
		341	+
		342	+	state := d.barStateFor(cur, "")
		343	+	require.GreaterOrEqual(t, len(state.mru), 2)
		344	+	require.Equal(t, []string{"alpha", "zeta"}, []string{state.mru[0].name, state.mru[1].name})
		345	+	}
		346	+
324	func TestStatusBarRendersMRUNamesEphemeralAndInlineBell(t *testing.T) {	347		func TestStatusBarRendersMRUNamesEphemeralAndInlineBell(t *testing.T) {
325	state := barState{	348		state := barState{
326	status: statusSnapshot{session: "cur"},	349		status: statusSnapshot{session: "cur"},