fix: support Cursor's nested transcript directory layout (#243)

## Summary

- Cursor recently changed its transcript storage from a flat layout
(`agent-transcripts/<uuid>.jsonl`) to a nested layout
(`agent-transcripts/<uuid>/<uuid>.jsonl`). The discovery and source file
lookup functions only handled the flat layout, causing sessions from
newer Cursor versions to be invisible.
- Updates `DiscoverCursorSessions` and `FindCursorSourceFile` to handle
both flat and nested layouts.
- Extracts dedup logic into `cursorAddSeen` helper to avoid repetition
between the two code paths.

## Test plan

- [x] New table-driven tests for nested layout discovery (jsonl, txt,
dedup, mixed flat+nested)
- [x] New tests for `FindCursorSourceFile` with nested layout
- [x] Existing flat-layout tests continue to pass
- [x] Verified against real Cursor transcript directory on macOS
(`~/.cursor/projects/`)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: cbb330

internal/parser/discovery.go

@@ -481,6 +481,22 @@ func confirmGeminiSessionID(
 // the Cursor projects dir (<projectsDir>/<project>/agent-transcripts/<uuid>.txt).
 // All discovered paths are validated to resolve within the
 // canonical projectsDir, preventing symlink escapes.
+// cursorAddSeen inserts a transcript path into the seen map,
+// preferring .jsonl over .txt when both exist for the same stem.
+func cursorAddSeen(
+	seen map[string]string, name, fullPath string,
+) {
+	stem := strings.TrimSuffix(name, filepath.Ext(name))
+	if prev, ok := seen[stem]; ok {
+		if strings.HasSuffix(prev, ".txt") &&
+			strings.HasSuffix(name, ".jsonl") {
+			seen[stem] = fullPath
+		}
+		return
+	}
+	seen[stem] = fullPath
+}
+
 func DiscoverCursorSessions(
 	projectsDir string,
 ) []DiscoveredFile {
@@ -538,33 +554,64 @@ func DiscoverCursorSessions(
 		// Collect valid transcripts, deduping by basename
 		// stem. When both .jsonl and .txt exist for the
 		// same session, prefer .jsonl.
+		//
+		// Cursor uses two layouts:
+		//   flat:   agent-transcripts/<uuid>.{txt,jsonl}
+		//   nested: agent-transcripts/<uuid>/<uuid>.{txt,jsonl}
 		seen := make(map[string]string) // stem -> path
 		for _, sf := range transcripts {
-			if sf.IsDir() {
-				continue
-			}
-			name := sf.Name()
-			if !IsCursorTranscriptExt(name) {
+			if !sf.IsDir() {
+				// Flat layout: file directly in
+				// agent-transcripts/.
+				name := sf.Name()
+				if !IsCursorTranscriptExt(name) {
+					continue
+				}
+				fullPath := filepath.Join(
+					transcriptsDir, name,
+				)
+				if !IsRegularFile(fullPath) {
+					continue
+				}
+				cursorAddSeen(seen, name, fullPath)
 				continue
 			}
-			fullPath := filepath.Join(
-				transcriptsDir, name,
+
+			// Nested layout: agent-transcripts/<uuid>/
+			// containing <uuid>.{txt,jsonl}.
+			subDir := filepath.Join(
+				transcriptsDir, sf.Name(),
 			)
-			if !IsRegularFile(fullPath) {
+			subEntries, err := os.ReadDir(subDir)
+			if err != nil {
 				continue
 			}
-			stem := strings.TrimSuffix(
-				name, filepath.Ext(name),
-			)
-			if prev, ok := seen[stem]; ok {
-				// .jsonl wins over .txt
-				if strings.HasSuffix(prev, ".txt") &&
-					strings.HasSuffix(name, ".jsonl") {
-					seen[stem] = fullPath
+			dirName := sf.Name()
+			for _, sub := range subEntries {
+				if sub.IsDir() {
+					continue
 				}
-				continue
+				name := sub.Name()
+				if !IsCursorTranscriptExt(name) {
+					continue
+				}
+				// Only accept files whose stem matches
+				// the parent directory name, e.g.
+				// <uuid>/<uuid>.jsonl.
+				stem := strings.TrimSuffix(
+					name, filepath.Ext(name),
+				)
+				if stem != dirName {
+					continue
+				}
+				fullPath := filepath.Join(
+					subDir, name,
+				)
+				if !IsRegularFile(fullPath) {
+					continue
+				}
+				cursorAddSeen(seen, name, fullPath)
 			}
-			seen[stem] = fullPath
 		}
 		for _, path := range seen {
 			files = append(files, DiscoveredFile{
@@ -606,28 +653,38 @@ func FindCursorSourceFile(
 			if !entry.IsDir() {
 				continue
 			}
-			candidate := filepath.Join(
-				projectsDir, entry.Name(),
-				"agent-transcripts", target,
-			)
-			if !IsRegularFile(candidate) {
-				continue
-			}
-			resolved, err := filepath.EvalSymlinks(
-				candidate,
-			)
-			if err != nil {
-				continue
+			// Nested layout first (matches discovery
+			// precedence), then flat layout.
+			candidates := []string{
+				filepath.Join(
+					projectsDir, entry.Name(),
+					"agent-transcripts", sessionID, target,
+				),
+				filepath.Join(
+					projectsDir, entry.Name(),
+					"agent-transcripts", target,
+				),
 			}
-			rel, err := filepath.Rel(
-				resolvedRoot, resolved,
-			)
-			sep := string(filepath.Separator)
-			if err != nil || rel == ".." ||
-				strings.HasPrefix(rel, ".."+sep) {
-				continue
+			for _, candidate := range candidates {
+				if !IsRegularFile(candidate) {
+					continue
+				}
+				resolved, err := filepath.EvalSymlinks(
+					candidate,
+				)
+				if err != nil {
+					continue
+				}
+				rel, err := filepath.Rel(
+					resolvedRoot, resolved,
+				)
+				sep := string(filepath.Separator)
+				if err != nil || rel == ".." ||
+					strings.HasPrefix(rel, ".."+sep) {
+					continue
+				}
+				return candidate
 			}
-			return candidate
 		}
 	}
 	return ""

internal/parser/discovery_test.go

@@ -1192,6 +1192,89 @@ func TestDiscoverCursorSessions(t *testing.T) {
 	}
 }
 
+func TestDiscoverCursorSessions_NestedLayout(t *testing.T) {
+	cursorTranscripts := filepath.Join(
+		"proj-dir", "agent-transcripts",
+	)
+
+	tests := []struct {
+		name      string
+		files     map[string]string
+		wantCount int
+	}{
+		{
+			name: "NestedJsonl",
+			files: map[string]string{
+				filepath.Join(cursorTranscripts, "aaa", "aaa.jsonl"): `{"role":"user"}`,
+			},
+			wantCount: 1,
+		},
+		{
+			name: "NestedTxt",
+			files: map[string]string{
+				filepath.Join(cursorTranscripts, "bbb", "bbb.txt"): "user:\nhi",
+			},
+			wantCount: 1,
+		},
+		{
+			name: "NestedWithSubagentsIgnored",
+			files: map[string]string{
+				filepath.Join(cursorTranscripts, "ccc", "ccc.jsonl"):               `{"role":"user"}`,
+				filepath.Join(cursorTranscripts, "ccc", "subagents", "sub1.jsonl"): `{"role":"user"}`,
+				filepath.Join(cursorTranscripts, "ccc", "subagents", "sub2.jsonl"): `{"role":"user"}`,
+			},
+			wantCount: 1,
+		},
+		{
+			name: "NestedDedupPrefersJsonl",
+			files: map[string]string{
+				filepath.Join(cursorTranscripts, "ddd", "ddd.txt"):   "user:\nhi",
+				filepath.Join(cursorTranscripts, "ddd", "ddd.jsonl"): `{"role":"user"}`,
+			},
+			wantCount: 1,
+		},
+		{
+			name: "NestedIgnoresAuxiliaryFiles",
+			files: map[string]string{
+				filepath.Join(cursorTranscripts, "eee", "eee.jsonl"):   `{"role":"user"}`,
+				filepath.Join(cursorTranscripts, "eee", "other.jsonl"): `{"role":"user"}`,
+				filepath.Join(cursorTranscripts, "eee", "notes.txt"):   "notes",
+			},
+			wantCount: 1,
+		},
+		{
+			name: "MixedFlatAndNested",
+			files: map[string]string{
+				filepath.Join(cursorTranscripts, "flat.txt"):               "user:\nhi",
+				filepath.Join(cursorTranscripts, "nested", "nested.jsonl"): `{"role":"user"}`,
+			},
+			wantCount: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := t.TempDir()
+			setupFileSystem(t, dir, tt.files)
+			files := DiscoverCursorSessions(dir)
+			if len(files) != tt.wantCount {
+				t.Fatalf(
+					"got %d files, want %d",
+					len(files), tt.wantCount,
+				)
+			}
+			for _, f := range files {
+				if f.Agent != AgentCursor {
+					t.Errorf(
+						"agent = %q, want %q",
+						f.Agent, AgentCursor,
+					)
+				}
+			}
+		})
+	}
+}
+
 func TestDiscoverCursorSessions_DedupPrefersJsonl(t *testing.T) {
 	dir := t.TempDir()
 	transcripts := filepath.Join(
@@ -1257,6 +1340,32 @@ func TestFindCursorSourceFile(t *testing.T) {
 		}
 	})
 
+	t.Run("FindsNestedJsonl", func(t *testing.T) {
+		dir := t.TempDir()
+		setupFileSystem(t, dir, map[string]string{
+			filepath.Join(cursorTranscripts, "sess4", "sess4.jsonl"): "{}",
+		})
+		got := FindCursorSourceFile(dir, "sess4")
+		if got == "" {
+			t.Fatal("expected to find nested .jsonl file")
+		}
+		if !strings.HasSuffix(got, filepath.Join("sess4", "sess4.jsonl")) {
+			t.Errorf("unexpected path %q", got)
+		}
+	})
+
+	t.Run("PrefersJsonlOverNestedTxt", func(t *testing.T) {
+		dir := t.TempDir()
+		setupFileSystem(t, dir, map[string]string{
+			filepath.Join(cursorTranscripts, "sess5", "sess5.txt"):   "old",
+			filepath.Join(cursorTranscripts, "sess5", "sess5.jsonl"): "new",
+		})
+		got := FindCursorSourceFile(dir, "sess5")
+		if !strings.HasSuffix(got, "sess5.jsonl") {
+			t.Errorf("expected .jsonl path, got %q", got)
+		}
+	})
+
 	t.Run("NotFound", func(t *testing.T) {
 		dir := t.TempDir()
 		got := FindCursorSourceFile(dir, "nonexistent")