fix: validate scoped aider exports and discovery

Author: wesm

cmd/agentsview/session_export.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"go.kenn.io/agentsview/internal/config"
@@ -69,6 +70,33 @@ func newSessionExportCommand() *cobra.Command {
 			// same repository.
 			if historyPath, idx, ok :=
 				parser.ParseAiderVirtualPath(storedPath); ok {
+				rawID, ok := rawAiderSessionID(id)
+				if !ok {
+					return fmt.Errorf(
+						"stale aider source for session %s: invalid aider session id",
+						id,
+					)
+				}
+				if got, ok := parser.AiderRawIDAt(historyPath, idx); !ok || got != rawID {
+					if _, statErr := os.Stat(historyPath); statErr != nil {
+						if os.IsNotExist(statErr) {
+							return fmt.Errorf(
+								"source file not found: %s", historyPath,
+							)
+						}
+						return statErr
+					}
+					resolved, found := parser.AiderVirtualPathForRawID(
+						historyPath, rawID,
+					)
+					if !found {
+						return fmt.Errorf(
+							"stale aider source for session %s: %s no longer contains the archived run",
+							id, historyPath,
+						)
+					}
+					historyPath, idx, _ = parser.ParseAiderVirtualPath(resolved)
+				}
 				err := parser.WriteAiderRunMarkdown(
 					cmd.OutOrStdout(), historyPath, idx,
 				)
@@ -110,3 +138,13 @@ func newSessionExportCommand() *cobra.Command {
 		},
 	}
 }
+
+func rawAiderSessionID(sessionID string) (string, bool) {
+	def, ok := parser.AgentByPrefix(sessionID)
+	if !ok || def.Type != parser.AgentAider {
+		return "", false
+	}
+	_, rawID := parser.StripHostPrefix(sessionID)
+	rawID = strings.TrimPrefix(rawID, def.IDPrefix)
+	return rawID, rawID != ""
+}

cmd/agentsview/session_test.go

@@ -690,22 +690,60 @@ func TestSessionExport_AiderVirtualPathStreamsOnlySelectedRun(t *testing.T) {
 	require.NoError(t, os.WriteFile(
 		history, []byte("ignored preamble\n"+run0+run1+run2), 0o600,
 	))
+	rawID, ok := parser.AiderRawIDAt(history, 1)
+	require.True(t, ok, "run 1 raw ID")
 
-	seedSessionWithOpts(t, dataDir, "s-aider", "repo",
+	seedSessionWithOpts(t, dataDir, "aider:"+rawID, "repo",
 		func(s *db.Session) {
 			s.Agent = string(parser.AgentAider)
 			vp := parser.AiderVirtualPath(history, 1)
 			s.FilePath = &vp
 		})
 
 	out, err := executeCommand(newRootCommand(),
-		"session", "export", "s-aider")
+		"session", "export", "aider:"+rawID)
 	require.NoError(t, err)
 	assert.Equal(t, run1, out)
 	assert.NotContains(t, out, "first prompt")
 	assert.NotContains(t, out, "third prompt")
 }
 
+func TestSessionExport_AiderStaleIndexReResolvesBySessionID(t *testing.T) {
+	dataDir := t.TempDir()
+	t.Setenv("AGENTSVIEW_DATA_DIR", dataDir)
+
+	repo := filepath.Join(t.TempDir(), "repo")
+	require.NoError(t, os.MkdirAll(repo, 0o755))
+	history := filepath.Join(repo, parser.AiderHistoryFileName())
+	run0 := "# aider chat started at 2026-06-09 14:01:00\n" +
+		"#### first prompt\nanswer one\n"
+	run1 := "# aider chat started at 2026-06-09 15:30:00\n" +
+		"#### second prompt\nanswer two\n"
+	require.NoError(t, os.WriteFile(history, []byte(run0+run1), 0o600))
+	rawID, ok := parser.AiderRawIDAt(history, 1)
+	require.True(t, ok, "run 1 raw ID")
+
+	seedSessionWithOpts(t, dataDir, "aider:"+rawID, "repo",
+		func(s *db.Session) {
+			s.Agent = string(parser.AgentAider)
+			vp := parser.AiderVirtualPath(history, 1)
+			s.FilePath = &vp
+		})
+
+	inserted := "# aider chat started at 2026-06-09 13:00:00\n" +
+		"#### inserted prompt\ninserted answer\n"
+	require.NoError(t, os.WriteFile(
+		history, []byte(inserted+run0+run1), 0o600,
+	))
+
+	out, err := executeCommand(newRootCommand(),
+		"session", "export", "aider:"+rawID)
+	require.NoError(t, err)
+	assert.Equal(t, run1, out)
+	assert.NotContains(t, out, "inserted prompt")
+	assert.NotContains(t, out, "first prompt")
+}
+
 func TestSessionExport_FailsWhenSourceMissing(t *testing.T) {
 	dataDir := t.TempDir()
 	t.Setenv("AGENTSVIEW_DATA_DIR", dataDir)

internal/parser/aider.go

@@ -89,6 +89,29 @@ var aiderSkipDirs = map[string]struct{}{
 	".hg":          {},
 }
 
+// AiderDiscoverySkipDirNames returns the directory basenames pruned by Aider
+// discovery. Remote SSH discovery uses this to mirror local discovery semantics.
+func AiderDiscoverySkipDirNames() []string {
+	names := make([]string, 0, len(aiderSkipDirs))
+	for name := range aiderSkipDirs {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
+}
+
+// AiderDiscoveryMaxWalkDepth returns the maximum directory depth local Aider
+// discovery descends below the configured root.
+func AiderDiscoveryMaxWalkDepth() int { return aiderMaxWalkDepth }
+
+// AiderDiscoveryMaxFiles returns the maximum number of Aider history files
+// local discovery returns from one configured root.
+func AiderDiscoveryMaxFiles() int { return aiderMaxFiles }
+
+// AiderDiscoveryMaxDirs returns the maximum number of directories local Aider
+// discovery visits below one configured root.
+func AiderDiscoveryMaxDirs() int { return aiderMaxDirs }
+
 // AiderHistoryFileName returns the fixed Markdown filename aider writes
 // per repo (".aider.chat.history.md"). The sync engine uses it to match
 // watched files back to the aider agent.
@@ -429,6 +452,32 @@ func AiderRawIDAt(historyPath string, idx int) (string, bool) {
 	return aiderRawID(aiderAbsPath(historyPath), runs[idx].rawHeader, ordinals[idx]), true
 }
 
+// AiderVirtualPathForRawID resolves rawID to its current positional virtual
+// path within one physical history file. This is used when a previously stored
+// "<history>#<idx>" path has gone stale because an earlier run was inserted or
+// removed after the last sync.
+func AiderVirtualPathForRawID(historyPath, rawID string) (string, bool) {
+	if historyPath == "" || rawID == "" {
+		return "", false
+	}
+	data, err := os.ReadFile(historyPath)
+	if err != nil {
+		return "", false
+	}
+	runs := splitAiderRuns(string(data))
+	if len(runs) == 0 {
+		return "", false
+	}
+	absPath := aiderAbsPath(historyPath)
+	ordinals := aiderEqualHeaderOrdinals(runs)
+	for idx, run := range runs {
+		if aiderRawID(absPath, run.rawHeader, ordinals[idx]) == rawID {
+			return AiderVirtualPath(historyPath, idx), true
+		}
+	}
+	return "", false
+}
+
 // AiderRunMeta describes one run within a history file: its virtual
 // source path, positional index, and parsed start time. The sync engine
 // fans a physical file out into one session per meta. HasMessages reports
@@ -735,20 +784,8 @@ func FindAiderSourceFile(root, rawID string) string {
 		return ""
 	}
 	for _, f := range DiscoverAiderSessions(root) {
-		data, err := os.ReadFile(f.Path)
-		if err != nil {
-			continue
-		}
-		runs := splitAiderRuns(string(data))
-		if len(runs) == 0 {
-			continue
-		}
-		absPath := aiderAbsPath(f.Path)
-		ordinals := aiderEqualHeaderOrdinals(runs)
-		for idx, run := range runs {
-			if aiderRawID(absPath, run.rawHeader, ordinals[idx]) == rawID {
-				return AiderVirtualPath(f.Path, idx)
-			}
+		if path, ok := AiderVirtualPathForRawID(f.Path, rawID); ok {
+			return path
 		}
 	}
 	return ""

internal/ssh/resolve.go

@@ -13,6 +13,52 @@ import (
 // is not a valid agent type, so parseResolvedDirs routes it separately.
 const resolveFilePrefix = "@file"
 
+func aiderSkipDirCasePattern() string {
+	return strings.Join(parser.AiderDiscoverySkipDirNames(), "|")
+}
+
+func buildAiderResolveSnippet(envVar string) string {
+	return fmt.Sprintf(
+		"av_aider_walk() { "+
+			"[ \"$av_aider_files\" -ge %d ] && return; "+
+			"[ \"$av_aider_dirs\" -ge %d ] && return; "+
+			"for av_entry in \"$1\"/* \"$1\"/.[!.]* \"$1\"/..?*; do "+
+			"[ -e \"$av_entry\" ] || continue; "+
+			"[ -L \"$av_entry\" ] && continue; "+
+			"av_base=${av_entry##*/}; "+
+			"if [ -d \"$av_entry\" ]; then "+
+			"case \"$av_base\" in %s) continue;; esac; "+
+			"[ \"$2\" -ge %d ] && continue; "+
+			"av_aider_dirs=$((av_aider_dirs + 1)); "+
+			"av_aider_walk \"$av_entry\" $(($2 + 1)); "+
+			"[ \"$av_aider_files\" -ge %d ] && return; "+
+			"[ \"$av_aider_dirs\" -ge %d ] && return; "+
+			"elif [ -f \"$av_entry\" ] && [ \"$av_base\" = '%s' ]; then "+
+			"echo \"%s:$av_entry\"; "+
+			"av_aider_files=$((av_aider_files + 1)); "+
+			"[ \"$av_aider_files\" -ge %d ] && return; "+
+			"fi; "+
+			"done; "+
+			"}; "+
+			"dir=\"${%s:-}\"; "+
+			"case \"$dir\" in \"\"|\"$HOME\"|\"$HOME/\") ;; "+
+			"*) if [ -d \"$dir\" ]; then "+
+			"av_aider_files=0; av_aider_dirs=1; "+
+			"av_aider_walk \"$dir\" 0; "+
+			"fi;; esac\n",
+		parser.AiderDiscoveryMaxFiles(),
+		parser.AiderDiscoveryMaxDirs(),
+		aiderSkipDirCasePattern(),
+		parser.AiderDiscoveryMaxWalkDepth(),
+		parser.AiderDiscoveryMaxFiles(),
+		parser.AiderDiscoveryMaxDirs(),
+		parser.AiderHistoryFileName(),
+		string(parser.AgentAider),
+		parser.AiderDiscoveryMaxFiles(),
+		envVar,
+	)
+}
+
 // buildResolveScript generates a shell script that echoes each file-based
 // agent's resolved transfer target on the remote host. Output format:
 // "agentType:path\n" per agent target, plus "@file:path\n" lines for sibling
@@ -43,16 +89,7 @@ func buildResolveScript() string {
 			// whole-home scan or tar.
 			if def.Type == parser.AgentAider && rel == "" {
 				if def.EnvVar != "" {
-					fmt.Fprintf(&b,
-						"dir=\"${%s:-}\"; "+
-							"case \"$dir\" in \"\"|\"$HOME\"|\"$HOME/\") ;; "+
-							"*) if [ -d \"$dir\" ]; then "+
-							"find \"$dir\" -type f -name '%s' -print | sort | "+
-							"while IFS= read -r f; do echo \"%s:$f\"; done; "+
-							"fi;; esac\n",
-						def.EnvVar, parser.AiderHistoryFileName(),
-						string(def.Type),
-					)
+					b.WriteString(buildAiderResolveSnippet(def.EnvVar))
 				}
 				continue
 			}

internal/ssh/resolve_test.go

@@ -157,6 +157,14 @@ func TestResolveScriptAiderScopedByEnvFindsHistoryFiles(t *testing.T) {
 	require.NoError(t, os.WriteFile(
 		filepath.Join(repoA, "source.go"), []byte("package main\n"), 0o644,
 	))
+	skippedDir := filepath.Join(codeRoot, "node_modules", "dep")
+	require.NoError(t, os.MkdirAll(skippedDir, 0o755), "mkdir skipped dir")
+	skippedHistory := filepath.Join(skippedDir, parser.AiderHistoryFileName())
+	require.NoError(t, os.WriteFile(skippedHistory, []byte("# aider\n"), 0o644))
+	deepDir := filepath.Join(codeRoot, "a", "b", "c", "d", "e")
+	require.NoError(t, os.MkdirAll(deepDir, 0o755), "mkdir deep dir")
+	deepHistory := filepath.Join(deepDir, parser.AiderHistoryFileName())
+	require.NoError(t, os.WriteFile(deepHistory, []byte("# aider\n"), 0o644))
 
 	script := buildResolveScript()
 	cmd := exec.Command("sh", "-c", script)
@@ -169,6 +177,10 @@ func TestResolveScriptAiderScopedByEnvFindsHistoryFiles(t *testing.T) {
 		"explicit AIDER_DIR must resolve only aider history files")
 	assert.NotContains(t, dirs[parser.AgentAider], codeRoot,
 		"AIDER_DIR itself must not become a tar target")
+	assert.NotContains(t, dirs[parser.AgentAider], skippedHistory,
+		"remote aider discovery must prune local-discovery skip dirs")
+	assert.NotContains(t, dirs[parser.AgentAider], deepHistory,
+		"remote aider discovery must enforce the local depth cap")
 }
 
 // TestResolveScriptAiderRejectsHomeOverride verifies that setting AIDER_DIR