fix(parser): preserve gptme provider source parity

The gptme provider is intended to be a no-behavior-change facade migration, so it needs to preserve the legacy source semantics before sync callers can safely move to it. Symlinked session directories, deleted source events, and persisted lookup hints are all observable through the current discovery and session lookup paths.

This keeps provider-backed gptme discovery and changed-path classification compatible with those legacy expectations while leaving runtime dispatch unchanged.

Author: mariusvniekerk

internal/parser/gptme_provider.go

@@ -61,7 +61,15 @@ func (p *gptmeProvider) SourcesForChangedPath(
 	if err != nil {
 		return nil, err
 	}
-	return p.filterSources(sources), nil
+	filtered := p.filterSources(sources)
+	if len(filtered) > 0 {
+		return filtered, nil
+	}
+	source, ok := p.sourceForEventPath(req)
+	if !ok {
+		return nil, nil
+	}
+	return []SourceRef{source}, nil
 }
 
 func (p *gptmeProvider) FindSource(
@@ -71,25 +79,88 @@ func (p *gptmeProvider) FindSource(
 	if err := ctx.Err(); err != nil {
 		return SourceRef{}, false, err
 	}
-	if req.StoredFilePath != "" {
-		source, ok := p.sources.sourceForPath(req.StoredFilePath)
-		if ok && p.isSource(source) {
+	for _, path := range []string{
+		req.StoredFilePath,
+		req.FingerprintKey,
+	} {
+		if path == "" {
+			continue
+		}
+		if source, ok := p.sourceForExistingPath(path); ok {
 			return source, true, nil
 		}
 	}
-	if req.RawSessionID == "" {
-		return SourceRef{}, false, nil
-	}
-	for _, root := range p.Config.Roots {
-		path := filepath.Join(root, req.RawSessionID, "conversation.jsonl")
-		source, ok := p.sources.sourceForPath(path)
-		if ok && p.isSource(source) {
+	for _, id := range []string{
+		req.RawSessionID,
+		p.rawSessionIDFromFull(req.FullSessionID),
+	} {
+		if id == "" {
+			continue
+		}
+		if source, ok := p.sourceForSessionID(id); ok {
 			return source, true, nil
 		}
 	}
 	return SourceRef{}, false, nil
 }
 
+func (p *gptmeProvider) sourceForExistingPath(path string) (SourceRef, bool) {
+	source, ok := p.sources.sourceForPath(path)
+	if ok && p.isSource(source) {
+		return source, true
+	}
+	return SourceRef{}, false
+}
+
+func (p *gptmeProvider) sourceForSessionID(id string) (SourceRef, bool) {
+	for _, root := range p.Config.Roots {
+		path := filepath.Join(root, id, "conversation.jsonl")
+		if source, ok := p.sourceForExistingPath(path); ok {
+			return source, true
+		}
+	}
+	return SourceRef{}, false
+}
+
+func (p *gptmeProvider) rawSessionIDFromFull(id string) string {
+	if id == "" {
+		return ""
+	}
+	_, rawID := StripHostPrefix(id)
+	if !strings.HasPrefix(rawID, p.Def.IDPrefix) {
+		return ""
+	}
+	return strings.TrimPrefix(rawID, p.Def.IDPrefix)
+}
+
+func (p *gptmeProvider) sourceForEventPath(req ChangedPathRequest) (SourceRef, bool) {
+	if req.Path == "" {
+		return SourceRef{}, false
+	}
+	if req.WatchRoot != "" {
+		root := filepath.Clean(req.WatchRoot)
+		if !p.hasRoot(root) {
+			return SourceRef{}, false
+		}
+		return gptmeSourceRef(root, filepath.Clean(req.Path))
+	}
+	for _, root := range p.Config.Roots {
+		if source, ok := gptmeSourceRef(root, filepath.Clean(req.Path)); ok {
+			return source, true
+		}
+	}
+	return SourceRef{}, false
+}
+
+func (p *gptmeProvider) hasRoot(root string) bool {
+	for _, configured := range p.Config.Roots {
+		if samePath(configured, root) {
+			return true
+		}
+	}
+	return false
+}
+
 func (p *gptmeProvider) Fingerprint(
 	ctx context.Context,
 	source SourceRef,
@@ -157,8 +228,9 @@ func (p *gptmeProvider) isSource(source SourceRef) bool {
 
 func newGptmeSourceSet(roots []string) JSONLSourceSet {
 	return NewJSONLSourceSet(AgentGptme, roots, JSONLSourceSetOptions{
-		Recursive: true,
-		Hash:      true,
+		Recursive:         true,
+		Hash:              true,
+		FollowSymlinkDirs: true,
 		Include: func(path string, info os.FileInfo) bool {
 			return !info.IsDir() && filepath.Base(path) == "conversation.jsonl"
 		},
@@ -210,3 +282,24 @@ func gptmeSessionIDFromPath(root, path string) string {
 	}
 	return filepath.Base(filepath.Dir(path))
 }
+
+func gptmeSourceRef(root, path string) (SourceRef, bool) {
+	root = filepath.Clean(root)
+	path = filepath.Clean(path)
+	if !isGptmeConversationPath(root, path) {
+		return SourceRef{}, false
+	}
+	sessionID := gptmeSessionIDFromPath(root, path)
+	return SourceRef{
+		Provider:       AgentGptme,
+		Key:            path,
+		DisplayPath:    path,
+		FingerprintKey: path,
+		ProjectHint:    gptmeProjectFromSessionName(sessionID),
+		Opaque: JSONLSource{
+			Root:    root,
+			Path:    path,
+			RelPath: filepath.Join(sessionID, "conversation.jsonl"),
+		},
+	}, true
+}

internal/parser/gptme_provider_test.go

@@ -3,6 +3,7 @@ package parser
 import (
 	"context"
 	"errors"
+	"os"
 	"path/filepath"
 	"testing"
 
@@ -82,6 +83,89 @@ func TestGptmeProviderSourceMethods(t *testing.T) {
 	assert.NotEmpty(t, fingerprint.Hash)
 }
 
+func TestGptmeProviderDiscoversSymlinkSessionDirectories(t *testing.T) {
+	root := t.TempDir()
+	targetRoot := t.TempDir()
+	sessionID := "2026-06-13-write-hello-world"
+	targetDir := filepath.Join(targetRoot, sessionID)
+	writeSourceFile(
+		t,
+		filepath.Join(targetDir, "conversation.jsonl"),
+		gptmeProviderFixture(),
+	)
+	linkDir := filepath.Join(root, sessionID)
+	if err := os.Symlink(targetDir, linkDir); err != nil {
+		t.Skipf("creating directory symlink: %v", err)
+	}
+
+	provider, ok := NewProvider(AgentGptme, ProviderConfig{
+		Roots:   []string{root},
+		Machine: "devbox",
+	})
+	require.True(t, ok)
+
+	discovered, err := provider.Discover(context.Background())
+	require.NoError(t, err)
+	require.Len(t, discovered, 1)
+	assert.Equal(t, filepath.Join(linkDir, "conversation.jsonl"), discovered[0].DisplayPath)
+
+	legacy := DiscoverGptmeSessions(root)
+	require.Len(t, legacy, 1)
+	assert.Equal(t, legacy[0].Path, discovered[0].DisplayPath)
+}
+
+func TestGptmeProviderClassifiesDeletedConversationPath(t *testing.T) {
+	root := t.TempDir()
+	sessionID := "2026-06-13-write-hello-world"
+	sourcePath := filepath.Join(root, sessionID, "conversation.jsonl")
+	writeSourceFile(t, sourcePath, gptmeProviderFixture())
+
+	provider, ok := NewProvider(AgentGptme, ProviderConfig{
+		Roots:   []string{root},
+		Machine: "devbox",
+	})
+	require.True(t, ok)
+	require.NoError(t, os.Remove(sourcePath))
+
+	changed, err := provider.SourcesForChangedPath(
+		context.Background(),
+		ChangedPathRequest{
+			Path:      sourcePath,
+			EventKind: "remove",
+			WatchRoot: root,
+		},
+	)
+	require.NoError(t, err)
+	require.Len(t, changed, 1)
+	assert.Equal(t, sourcePath, changed[0].Key)
+	assert.Equal(t, sourcePath, changed[0].DisplayPath)
+	assert.Equal(t, "write-hello-world", changed[0].ProjectHint)
+}
+
+func TestGptmeProviderFindSourceUsesPersistedFallbacks(t *testing.T) {
+	root := t.TempDir()
+	sessionID := "2026-06-13-write-hello-world"
+	sourcePath := filepath.Join(root, sessionID, "conversation.jsonl")
+	writeSourceFile(t, sourcePath, gptmeProviderFixture())
+
+	provider, ok := NewProvider(AgentGptme, ProviderConfig{
+		Roots:   []string{root},
+		Machine: "devbox",
+	})
+	require.True(t, ok)
+
+	for _, req := range []FindSourceRequest{
+		{FingerprintKey: sourcePath},
+		{FullSessionID: "gptme:" + sessionID},
+		{FullSessionID: "host~gptme:" + sessionID},
+	} {
+		found, ok, err := provider.FindSource(context.Background(), req)
+		require.NoError(t, err)
+		require.Truef(t, ok, "request %#v", req)
+		assert.Equal(t, sourcePath, found.DisplayPath)
+	}
+}
+
 func TestGptmeProviderParse(t *testing.T) {
 	root := t.TempDir()
 	sessionID := "2026-06-13-write-hello-world"