@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/pi/catalogue.go

@@ -0,0 +1,370 @@
+package pi
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"io"
+	"math"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pisession"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// The session catalogue (port of src/pi/session-catalogue.ts): the set of Pi session files under
+// a root, most recently modified first, merged with live sessions the host is running.
+//
+// The catalogue is read-only. It opens files only to summarise them and never rewrites or
+// migrates one; Pi owns those files.
+
+const (
+	defaultCataloguePage = 30
+	maxCataloguePage     = 100
+	headerScanBytes      = 8192
+)
+
+type sessionFile struct {
+	path    string
+	mtimeMs float64
+}
+
+type catalogueEntry struct {
+	sessionFile
+	file    string
+	onDisk  bool
+	summary *ahptypes.SessionSummary
+}
+
+func mtimeMs(info os.FileInfo) float64 { return float64(info.ModTime().UnixNano()) / 1e6 }
+
+func listSessionFiles(root string) ([]sessionFile, error) {
+	dirs, err := os.ReadDir(root)
+	if err != nil {
+		// No sessions directory yet is an empty catalogue, not an error.
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	var files []sessionFile
+	for _, d := range dirs {
+		dirPath := filepath.Join(root, d.Name())
+		entries, err := os.ReadDir(dirPath)
+		if err != nil {
+			continue // a file at the top level, or a race with deletion
+		}
+		for _, e := range entries {
+			if !strings.HasSuffix(e.Name(), ".jsonl") {
+				continue
+			}
+			path := filepath.Join(dirPath, e.Name())
+			info, err := os.Stat(path)
+			if err != nil {
+				continue // deleted between the directory read and the stat
+			}
+			files = append(files, sessionFile{path, mtimeMs(info)})
+		}
+	}
+	sortFiles(files)
+	return files, nil
+}
+
+// sortFiles orders by recency; ties break by path so the keyset cursor is total and stable.
+func sortFiles(files []sessionFile) {
+	sort.Slice(files, func(i, j int) bool {
+		if files[i].mtimeMs != files[j].mtimeMs {
+			return files[i].mtimeMs > files[j].mtimeMs
+		}
+		return files[i].path < files[j].path
+	})
+}
+
+func encodeCursor(f sessionFile) string {
+	raw := strconv.FormatFloat(f.mtimeMs, 'f', -1, 64) + "\x00" + f.path
+	return base64.RawURLEncoding.EncodeToString([]byte(raw))
+}
+
+func decodeCursor(cursor string) (sessionFile, error) {
+	raw, err := base64.RawURLEncoding.DecodeString(cursor)
+	bad := wire.InvalidParams("Unrecognised listSessions cursor")
+	if err != nil {
+		return sessionFile{}, bad
+	}
+	s := string(raw)
+	sep := strings.IndexByte(s, 0)
+	if sep < 0 {
+		return sessionFile{}, bad
+	}
+	ms, err := strconv.ParseFloat(s[:sep], 64)
+	path := s[sep+1:]
+	if err != nil || math.IsInf(ms, 0) || math.IsNaN(ms) || path == "" {
+		return sessionFile{}, bad
+	}
+	return sessionFile{path, ms}, nil
+}
+
+// readSessionID reads the id from a session file's header line without loading the file.
+func readSessionID(path string) (string, bool) {
+	f, err := os.Open(path)
+	if err != nil {
+		return "", false
+	}
+	defer f.Close()
+	buf := make([]byte, headerScanBytes)
+	n, err := io.ReadFull(f, buf)
+	if err != nil && err != io.ErrUnexpectedEOF && err != io.EOF {
+		return "", false
+	}
+	line := buf[:n]
+	if i := strings.IndexByte(string(line), '\n'); i >= 0 {
+		line = line[:i]
+	}
+	var header struct {
+		Type string `json:"type"`
+		ID   string `json:"id"`
+	}
+	if json.Unmarshal(line, &header) != nil || header.Type != "session" || header.ID == "" {
+		return "", false
+	}
+	return header.ID, true
+}
+
+func isoMs(ms float64) string {
+	return time.UnixMilli(int64(ms)).UTC().Format("2006-01-02T15:04:05.000Z")
+}
+
+// SessionName mirrors Pi: the latest session_info name.
+func sessionNameOf(entries []pisession.Entry) string {
+	for i := len(entries) - 1; i >= 0; i-- {
+		if entries[i].Type() == "session_info" {
+			s, _ := entries[i]["name"].(string)
+			return strings.TrimSpace(s)
+		}
+	}
+	return ""
+}
+
+// firstUserMessage is the first non-blank user text in a session.
+func firstUserMessage(entries []pisession.Entry) string {
+	for _, e := range entries {
+		if msg := e.Message(); msg != nil && msg["role"] == "user" {
+			if text := strings.TrimSpace(mapper.TextFromPiUserContent(msg["content"])); text != "" {
+				return text
+			}
+		}
+	}
+	return ""
+}
+
+func readSessionSummary(f sessionFile) (ahptypes.SessionSummary, bool) {
+	all, err := pisession.LoadEntries(f.path)
+	if err != nil || len(all) == 0 {
+		return ahptypes.SessionSummary{}, false
+	}
+	header, entries := all[0], all[1:]
+	sessionID, _ := header["id"].(string)
+	if sessionID == "" {
+		return ahptypes.SessionSummary{}, false
+	}
+	createdAt := ""
+	if len(entries) > 0 {
+		createdAt = entries[0].Timestamp()
+	}
+	if createdAt == "" {
+		createdAt = isoMs(f.mtimeMs)
+	}
+	meta, _ := json.Marshal(f.path)
+	summary := ahptypes.SessionSummary{
+		Resource: wire.SessionURI(sessionID), Provider: Provider,
+		Title: mapper.SessionDisplayTitle(sessionNameOf(entries), firstUserMessage(entries)),
+		// Idle by definition, and reported as read. Read/unread is not modelled: Pi has no such
+		// concept, so tracking it would mean this host inventing durable state of its own, and
+		// without archiving to go with it, a catalogue where everything is permanently unread is
+		// worse than one that is quiet.
+		Status:     ahptypes.SessionStatusIdle | ahptypes.SessionStatusIsRead,
+		CreatedAt:  createdAt,
+		ModifiedAt: isoMs(f.mtimeMs),
+		Meta:       map[string]json.RawMessage{"piSessionFile": meta},
+	}
+	if cwd, _ := header["cwd"].(string); cwd != "" {
+		summary.WorkingDirectories = []ahptypes.URI{wire.PathToFileURI(cwd)}
+	}
+	return summary, true
+}
+
+// Catalogue lists Pi session files under a root.
+type Catalogue struct {
+	root string
+
+	mu    sync.Mutex
+	index map[string]string // session URI -> file
+}
+
+// NewCatalogue creates a catalogue over a sessions root (one sub-directory per working directory).
+func NewCatalogue(root string) *Catalogue { return &Catalogue{root: root, index: map[string]string{}} }
+
+// FileFor is the file last seen for a session URI.
+func (c *Catalogue) FileFor(uri string) (string, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	f, ok := c.index[uri]
+	return f, ok
+}
+
+// FindSessionFile locates the file behind a session id, "" if there is none.
+func (c *Catalogue) FindSessionFile(sessionID string) (string, error) {
+	uri := wire.SessionURI(sessionID)
+	c.mu.Lock()
+	cached, ok := c.index[uri]
+	c.mu.Unlock()
+	if ok {
+		// The cache is only an index hint: deletion by this host, Pi, or the user must invalidate
+		// a path before it is returned again.
+		if id, ok := readSessionID(cached); ok && id == sessionID {
+			return cached, nil
+		}
+		c.mu.Lock()
+		delete(c.index, uri)
+		c.mu.Unlock()
+	}
+	files, err := listSessionFiles(c.root)
+	if err != nil {
+		return "", err
+	}
+	for _, f := range files {
+		id, ok := readSessionID(f.path)
+		if ok {
+			c.mu.Lock()
+			c.index[wire.SessionURI(id)] = f.path
+			c.mu.Unlock()
+		}
+		if ok && id == sessionID {
+			return f.path, nil
+		}
+	}
+	return "", nil
+}
+
+// List serves listSessions: one page of the catalogue, live sessions overriding what is on disk.
+func (c *Catalogue) List(_ context.Context, limit *int64, cursor *string, live func() []LiveCatalogueEntry) (ahptypes.ListSessionsResult, error) {
+	pageSize := int64(defaultCataloguePage)
+	if limit != nil {
+		pageSize = *limit
+	}
+	if pageSize < 1 {
+		pageSize = 1
+	}
+	if pageSize > maxCataloguePage {
+		pageSize = maxCataloguePage
+	}
+	files, err := listSessionFiles(c.root)
+	if err != nil {
+		return ahptypes.ListSessionsResult{}, err
+	}
+	entries := map[string]*catalogueEntry{}
+	for _, f := range files {
+		entries[f.path] = &catalogueEntry{sessionFile: f, file: f.path, onDisk: true}
+	}
+	// Live state is read after disk discovery, and the page is built without further waiting, so a
+	// turn transition cannot make the returned page older than a notification sent before it.
+	if live != nil {
+		for _, item := range live() {
+			ms := 0.0
+			if t, err := time.Parse(time.RFC3339Nano, item.Summary.ModifiedAt); err == nil {
+				ms = float64(t.UnixNano()) / 1e6
+			}
+			path := item.File
+			if path == "" {
+				path = "live:" + item.Summary.Resource
+			}
+			summary := item.Summary
+			entry := &catalogueEntry{sessionFile: sessionFile{path, ms}, file: item.File, summary: &summary}
+			if existing := entries[path]; existing != nil && existing.onDisk {
+				entry.onDisk = true
+			}
+			entries[path] = entry
+		}
+	}
+	ordered := make([]*catalogueEntry, 0, len(entries))
+	for _, e := range entries {
+		ordered = append(ordered, e)
+	}
+	sort.Slice(ordered, func(i, j int) bool {
+		if ordered[i].mtimeMs != ordered[j].mtimeMs {
+			return ordered[i].mtimeMs > ordered[j].mtimeMs
+		}
+		return ordered[i].path < ordered[j].path
+	})
+
+	start := 0
+	if cursor != nil {
+		after, err := decodeCursor(*cursor)
+		if err != nil {
+			return ahptypes.ListSessionsResult{}, err
+		}
+		index := -1
+		for i, e := range ordered {
+			if e.path == after.path {
+				index = i
+				break
+			}
+		}
+		if index < 0 {
+			// The entry the cursor named is gone (deleted between pages): fall back to the
+			// position it would have occupied rather than failing the whole call.
+			for i, e := range ordered {
+				if e.mtimeMs < after.mtimeMs || (e.mtimeMs == after.mtimeMs && e.path > after.path) {
+					index = i
+					break
+				}
+			}
+			if index < 0 {
+				return ahptypes.ListSessionsResult{Items: []ahptypes.SessionSummary{}}, nil
+			}
+			start = index
+		} else {
+			start = index + 1
+		}
+	}
+	end := start + int(pageSize)
+	if end > len(ordered) {
+		end = len(ordered)
+	}
+	page := ordered[start:end]
+	items := []ahptypes.SessionSummary{}
+	for _, e := range page {
+		var summary ahptypes.SessionSummary
+		ok := false
+		switch {
+		case e.summary != nil:
+			summary, ok = *e.summary, true
+		case e.file != "":
+			summary, ok = readSessionSummary(sessionFile{e.file, e.mtimeMs})
+		}
+		if !ok {
+			continue
+		}
+		if e.file != "" && e.onDisk {
+			c.mu.Lock()
+			c.index[summary.Resource] = e.file
+			c.mu.Unlock()
+		}
+		items = append(items, summary)
+	}
+	result := ahptypes.ListSessionsResult{Items: items}
+	if end < len(ordered) && len(page) > 0 {
+		next := encodeCursor(page[len(page)-1].sessionFile)
+		result.NextCursor = &next
+	}
+	return result, nil
+}

package/extensions/ahp/internal/pi/catalogue_test.go

@@ -0,0 +1,271 @@
+package pi_test
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// Twins of upstream test/session-catalogue.test.ts: ordering, pagination, title derivation, live
+// overlays, over a synthetic sessions directory.
+
+func list(t *testing.T, c *pi.Catalogue, limit int64, cursor *string, live func() []pi.LiveCatalogueEntry) ahptypes.ListSessionsResult {
+	t.Helper()
+	var l *int64
+	if limit > 0 {
+		l = &limit
+	}
+	result, err := c.List(context.Background(), l, cursor, live)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return result
+}
+
+func resources(items []ahptypes.SessionSummary) []string {
+	out := []string{}
+	for _, i := range items {
+		out = append(out, i.Resource)
+	}
+	return out
+}
+
+func TestSessionCatalogue(t *testing.T) {
+	root := t.TempDir()
+	var ids []string
+	// Interleave two working directories so the walk covers more than one session dir.
+	for i := 0; i < 5; i++ {
+		id := newID()
+		ids = append(ids, id)
+		cwd := "/tmp/project-b"
+		if i%2 == 0 {
+			cwd = "/tmp/project a"
+		}
+		writeFakeSession(t, root, id, fakeSession{cwd: cwd, firstUserMessage: "Message number " + itoa(i), mtimeSeconds: 1_700_000_000 + int64(i)})
+	}
+	catalogue := pi.NewCatalogue(root)
+
+	twin.Run(t, "session-catalogue", "returns most-recently-modified first, across working directories", func(t *testing.T) {
+		result := list(t, catalogue, 0, nil, nil)
+		if len(result.Items) != 5 {
+			t.Fatalf("%d items", len(result.Items))
+		}
+		var want []string
+		for i := len(ids) - 1; i >= 0; i-- {
+			want = append(want, wire.SessionURI(ids[i]))
+		}
+		if got := resources(result.Items); !reflect.DeepEqual(got, want) {
+			t.Fatalf("order = %v", got)
+		}
+		if got := result.Items[0].WorkingDirectories; !reflect.DeepEqual(got, []ahptypes.URI{wire.PathToFileURI("/tmp/project a")}) {
+			t.Fatalf("workingDirectories = %v", got)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "paginates with an opaque cursor and stops at the end", func(t *testing.T) {
+		first := list(t, catalogue, 2, nil, nil)
+		if len(first.Items) != 2 || first.NextCursor == nil {
+			t.Fatalf("first page = %+v", first)
+		}
+		second := list(t, catalogue, 2, first.NextCursor, nil)
+		if len(second.Items) != 2 || second.NextCursor == nil {
+			t.Fatalf("second page = %+v", second)
+		}
+		third := list(t, catalogue, 2, second.NextCursor, nil)
+		// A missing nextCursor is what signals the end of the catalogue.
+		if len(third.Items) != 1 || third.NextCursor != nil {
+			t.Fatalf("third page = %+v", third)
+		}
+		seen := map[string]bool{}
+		for _, page := range [][]ahptypes.SessionSummary{first.Items, second.Items, third.Items} {
+			for _, item := range page {
+				seen[item.Resource] = true
+			}
+		}
+		if len(seen) != 5 {
+			t.Fatalf("pages overlap: %d distinct", len(seen))
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "rejects a malformed cursor with InvalidParams", func(t *testing.T) {
+		bad := "not-a-cursor"
+		_, err := catalogue.List(context.Background(), ptr(int64(2)), &bad, nil)
+		var werr *wire.Error
+		if !errors.As(err, &werr) || werr.Code != wire.CodeInvalidParams {
+			t.Fatalf("err = %v", err)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "titles a session by its name, falling back to the first user message", func(t *testing.T) {
+		writeFakeSession(t, root, newID(), fakeSession{cwd: "/tmp/project-c", firstUserMessage: "This should lose to the explicit name", name: "Nightly refactor", mtimeSeconds: 1_700_001_000})
+		result := list(t, catalogue, 1, nil, nil)
+		// Same rule Pi's own /resume picker uses: name ?? firstMessage.
+		if result.Items[0].Title != "Nightly refactor" {
+			t.Fatalf("title = %q", result.Items[0].Title)
+		}
+		unnamed := list(t, catalogue, 2, nil, nil)
+		if unnamed.Items[1].Title != "Message number 4" {
+			t.Fatalf("title = %q", unnamed.Items[1].Title)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "skips files that are not readable pi sessions", func(t *testing.T) {
+		before := list(t, catalogue, 0, nil, nil)
+		dir := filepath.Join(root, "--tmp-project-broken--")
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, "1700002000_broken.jsonl"), []byte("not json at all\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		// One corrupt file must neither appear nor take down the catalogue.
+		if after := list(t, catalogue, 0, nil, nil); !reflect.DeepEqual(after, before) {
+			t.Fatalf("catalogue changed: %+v vs %+v", after, before)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "returns an empty catalogue when nothing exists yet", func(t *testing.T) {
+		empty := pi.NewCatalogue(filepath.Join(root, "does-not-exist"))
+		if got := list(t, empty, 0, nil, nil); len(got.Items) != 0 || got.NextCursor != nil {
+			t.Fatalf("got %+v", got)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "does not return a cached path after its session file is removed", func(t *testing.T) {
+		isolatedRoot := t.TempDir()
+		id := newID()
+		file := writeFakeSession(t, isolatedRoot, id, fakeSession{cwd: "/tmp/cached", firstUserMessage: "cache me", mtimeSeconds: 1_700_003_000})
+		isolated := pi.NewCatalogue(isolatedRoot)
+		list(t, isolated, 0, nil, nil)
+		if got, _ := isolated.FindSessionFile(id); got != file {
+			t.Fatalf("found %q, want %q", got, file)
+		}
+		if err := os.Remove(file); err != nil {
+			t.Fatal(err)
+		}
+		if got, _ := isolated.FindSessionFile(id); got != "" {
+			t.Fatalf("found a removed file: %q", got)
+		}
+	})
+}
+
+func ptr[T any](v T) *T { return &v }
+
+func liveSummary(id, title string, status ahptypes.SessionStatus, modified time.Time) ahptypes.SessionSummary {
+	return ahptypes.SessionSummary{
+		Resource: wire.SessionURI(id), Provider: "pi", Title: title, Status: status,
+		CreatedAt: time.UnixMilli(0).UTC().Format("2006-01-02T15:04:05.000Z"), ModifiedAt: modified.UTC().Format("2006-01-02T15:04:05.000Z"),
+	}
+}
+
+func TestLiveSessionCatalogueOverlays(t *testing.T) {
+	twin.Run(t, "session-catalogue", "reads live status after disk discovery rather than freezing request-start state", func(t *testing.T) {
+		// Upstream races an async scan against a state change. The Go scan is synchronous, so the
+		// property kept is that live state is read exactly once, when the page is built.
+		root := t.TempDir()
+		current := liveSummary(newID(), "Live", ahptypes.SessionStatusInProgress, time.UnixMilli(1000))
+		reads := 0
+		source := func() []pi.LiveCatalogueEntry {
+			reads++
+			return []pi.LiveCatalogueEntry{{Summary: current}}
+		}
+		current.Status, current.ModifiedAt = ahptypes.SessionStatusIdle, "1970-01-01T00:00:02.000Z"
+		got := list(t, pi.NewCatalogue(root), 1, nil, source)
+		if !reflect.DeepEqual(got.Items, []ahptypes.SessionSummary{current}) || got.NextCursor != nil {
+			t.Fatalf("got %+v", got)
+		}
+		if reads != 1 {
+			t.Fatalf("live source read %d times", reads)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "keeps a live entry stable as its file appears, without caching a nonexistent file", func(t *testing.T) {
+		root := t.TempDir()
+		id := newID()
+		options := fakeSession{cwd: "/tmp/live", firstUserMessage: "disk", mtimeSeconds: 100}
+		file := writeFakeSession(t, root, id, options)
+		if err := os.Remove(file); err != nil {
+			t.Fatal(err)
+		}
+		live := liveSummary(id, "Live", ahptypes.SessionStatusInProgress, time.UnixMilli(200000))
+		catalogue := pi.NewCatalogue(root)
+		source := func() []pi.LiveCatalogueEntry { return []pi.LiveCatalogueEntry{{File: file, Summary: live}} }
+		if got := list(t, catalogue, 1, nil, source); !reflect.DeepEqual(got.Items, []ahptypes.SessionSummary{live}) {
+			t.Fatalf("got %+v", got)
+		}
+		if _, cached := catalogue.FileFor(live.Resource); cached {
+			t.Fatal("cached a nonexistent file")
+		}
+		writeFakeSession(t, root, id, options)
+		if got := list(t, catalogue, 1, nil, source); !reflect.DeepEqual(got.Items, []ahptypes.SessionSummary{live}) {
+			t.Fatalf("got %+v", got)
+		}
+		if got, _ := catalogue.FileFor(live.Resource); got != file {
+			t.Fatalf("cached %q, want %q", got, file)
+		}
+	})
+
+	twin.Run(t, "session-catalogue", "orders and paginates live summaries without duplicating their files", func(t *testing.T) {
+		root := t.TempDir()
+		replacedID, olderID, liveOnlyID := newID(), newID(), newID()
+		replacedFile := writeFakeSession(t, root, replacedID, fakeSession{cwd: "/tmp/replaced", firstUserMessage: "stale disk title", mtimeSeconds: 100})
+		writeFakeSession(t, root, olderID, fakeSession{cwd: "/tmp/older", firstUserMessage: "older", mtimeSeconds: 200})
+		summary := func(id, title string, seconds int64) ahptypes.SessionSummary {
+			return liveSummary(id, title, ahptypes.SessionStatusInProgress, time.Unix(seconds, 0))
+		}
+		liveEntries := []pi.LiveCatalogueEntry{
+			{File: replacedFile, Summary: summary(replacedID, "live replacement", 400)},
+			{Summary: summary(liveOnlyID, "not on disk", 300)},
+		}
+		source := func() []pi.LiveCatalogueEntry { return liveEntries }
+		catalogue := pi.NewCatalogue(root)
+		first := list(t, catalogue, 2, nil, source)
+		if len(first.Items) != 2 || first.NextCursor == nil {
+			t.Fatalf("first = %+v", first)
+		}
+		second := list(t, catalogue, 2, first.NextCursor, source)
+		items := append(append([]ahptypes.SessionSummary{}, first.Items...), second.Items...)
+		want := []string{wire.SessionURI(replacedID), wire.SessionURI(liveOnlyID), wire.SessionURI(olderID)}
+		if got := resources(items); !reflect.DeepEqual(got, want) {
+			t.Fatalf("order = %v", got)
+		}
+		if items[0].Title != "live replacement" || items[0].Status != ahptypes.SessionStatusInProgress {
+			t.Fatalf("first item = %+v", items[0])
+		}
+		if second.NextCursor != nil {
+			t.Fatal("expected the end of the catalogue")
+		}
+	})
+}
+
+func TestListSessionsOverTheWire(t *testing.T) {
+	twin.Run(t, "session-catalogue", "serves a schema-conforming page", func(t *testing.T) {
+		root := t.TempDir()
+		writeFakeSession(t, root, newID(), fakeSession{cwd: "/tmp/wire", firstUserMessage: "Explain this repository", mtimeSeconds: 1_700_100_000})
+		h := startHarness(t, harnessOptions{sessionRoot: root})
+		client := testkit.Connect(t, h.host)
+		t.Cleanup(client.Close)
+		client.Initialize(nextClientID(), nil)
+		raw := client.Must("listSessions", obj{"channel": wire.RootChannel})
+		var result struct{ Items []obj }
+		if err := json.Unmarshal(raw, &result); err != nil {
+			t.Fatal(err)
+		}
+		if len(result.Items) != 1 || result.Items[0]["title"] != "Explain this repository" {
+			t.Fatalf("result = %s", raw)
+		}
+		testkit.AssertValid(t, "commands", "ListSessionsResult", testkit.Normalize(t, raw))
+	})
+}