fix(cli): record AI sessions for edits in git worktrees (#3469)

Author: jiparis

app/cli/internal/trace/claude/hooks_test.go

@@ -221,6 +221,7 @@ func TestReadHookInput(t *testing.T) {
 		assert.Equal(t, "abc-123", input.SessionID)
 		assert.Equal(t, "SessionStart", input.HookEventName)
 		assert.Equal(t, "Edit", input.ToolName)
+		assert.Equal(t, "/some/path", input.Cwd)
 	})
 
 	t.Run("extracts tool metadata", func(t *testing.T) {

app/cli/internal/trace/claude/provider.go

@@ -78,8 +78,8 @@ func (p *Provider) SessionDirForRepo(repoRoot string) string {
 // CopySessionData copies the Claude Code JSONL (and subagent files) from the
 // Claude project directory into the store's raw/ directory so pre-push can
 // parse them even if Claude rotates its own storage later.
-func (p *Provider) CopySessionData(store *state.Store, repoRoot, sessionID string) error {
-	sourceDir := p.SessionDirForRepo(repoRoot)
+func (p *Provider) CopySessionData(store *state.Store, agentCwd, sessionID string) error {
+	sourceDir := p.SessionDirForRepo(agentCwd)
 	if sourceDir == "" {
 		return nil
 	}

app/cli/internal/trace/cursor/hooks.go

@@ -172,6 +172,7 @@ type cursorHookInput struct {
 	HookEventName  string           `json:"hook_event_name"`
 	CursorVersion  string           `json:"cursor_version"`
 	Model          string           `json:"model"`
+	WorkspaceRoots []string         `json:"workspace_roots"`
 	FilePath       string           `json:"file_path"`
 	Edits          []cursorHookEdit `json:"edits"`
 }
@@ -212,6 +213,13 @@ func (p *Provider) ReadHookInput(r io.Reader) (*trace.HookInput, error) {
 		Model:         raw.Model,
 	}
 
+	// Cursor files transcripts under the workspace it was opened on. A
+	// multi-root workspace has no single answer; the first root is the one
+	// Cursor lists first and the best guess available.
+	if len(raw.WorkspaceRoots) > 0 {
+		input.Cwd = raw.WorkspaceRoots[0]
+	}
+
 	if raw.HookEventName == eventAfterFileEdit {
 		input.ToolName = syntheticEditToolName
 	}

app/cli/internal/trace/cursor/hooks_test.go

@@ -164,6 +164,7 @@ func TestReadHookInputAfterFileEdit(t *testing.T) {
 		"hook_event_name": "afterFileEdit",
 		"model": "claude-4",
 		"cursor_version": "0.48.0",
+		"workspace_roots": ["/abs/path", "/abs/other"],
 		"file_path": "/abs/path/file.go",
 		"edits": [
 			{"old_string": "foo", "new_string": "bar"},
@@ -178,6 +179,7 @@ func TestReadHookInputAfterFileEdit(t *testing.T) {
 	assert.Equal(t, "afterFileEdit", in.HookEventName, "HookEventName")
 	assert.Equal(t, syntheticEditToolName, in.ToolName, "ToolName")
 	assert.Equal(t, "/abs/path/file.go", in.FilePath, "FilePath")
+	assert.Equal(t, "/abs/path", in.Cwd, "Cwd is the first workspace root")
 	require.Len(t, in.Edits, 2, "Edits len")
 	assert.Equal(t, "foo", in.Edits[0].OldString, "first edit OldString")
 	assert.Equal(t, "bar", in.Edits[0].NewString, "first edit NewString")

app/cli/internal/trace/cursor/provider.go

@@ -138,8 +138,8 @@ func (p *Provider) CleanupAfterEdit(_ *state.Store, _ *trace.HookInput) {}
 // the store's raw/<sessionID>.jsonl. Handles both flat and nested
 // source layouts; the destination is always flat so downstream consumers
 // (parse, pre-push) don't need to re-resolve.
-func (p *Provider) CopySessionData(store *state.Store, repoRoot, sessionID string) error {
-	sourceDir := p.SessionDirForRepo(repoRoot)
+func (p *Provider) CopySessionData(store *state.Store, agentCwd, sessionID string) error {
+	sourceDir := p.SessionDirForRepo(agentCwd)
 	if sourceDir == "" {
 		return nil
 	}

app/cli/internal/trace/git/repo.go

@@ -46,6 +46,17 @@ func FindGitDirAndRoot() (gitDir, repoRoot string, err error) {
 	return findGitDirAndRoot()
 }
 
+// FindGitDirAndRootFrom is FindGitDirAndRoot starting from dir instead of
+// cwd. dir need not exist yet: the walk only probes for .git on the way up.
+func FindGitDirAndRootFrom(dir string) (gitDir, repoRoot string, err error) {
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return "", "", fmt.Errorf("resolve %q: %w", dir, err)
+	}
+
+	return findGitDirAndRootFrom(abs)
+}
+
 // findGitDirAndRoot walks up from cwd to locate .git, avoiding go-git's strict
 // config validation which fails on repos with invalid branch config.
 func findGitDirAndRoot() (string, string, error) {
@@ -54,7 +65,10 @@ func findGitDirAndRoot() (string, string, error) {
 		return "", "", fmt.Errorf("get working directory: %w", err)
 	}
 
-	dir := cwd
+	return findGitDirAndRootFrom(cwd)
+}
+
+func findGitDirAndRootFrom(dir string) (string, string, error) {
 	for {
 		dotGit := filepath.Join(dir, ".git")
 		fi, err := os.Lstat(dotGit)

app/cli/internal/trace/git/repo_test.go

@@ -210,3 +210,79 @@ func TestHooksInstallFromWorktree(t *testing.T) {
 			"hook %s should NOT be written to worktree-private hooks dir", name)
 	}
 }
+
+// Agent hooks run from the directory the session started in, which is not
+// necessarily the checkout that owns the file being edited (PFM-7412), so the
+// lookup has to start from an explicit directory rather than cwd.
+func TestFindGitDirAndRootFrom(t *testing.T) {
+	if _, err := exec.LookPath("git"); err != nil {
+		t.Skip("git binary not found, skipping worktree test")
+	}
+
+	mainDir, err := filepath.EvalSymlinks(t.TempDir())
+	require.NoError(t, err)
+	wtDir := filepath.Join(mainDir, ".claude", "worktrees", "feature")
+
+	run := func(args ...string) {
+		cmd := exec.Command("git", args...)
+		cmd.Dir = mainDir
+		out, err := cmd.CombinedOutput()
+		require.NoError(t, err, "git %v failed: %s", args, string(out))
+	}
+	run("init", "-b", "main")
+	run("config", "user.email", "test@test.com")
+	run("config", "user.name", "Test")
+	run("commit", "--allow-empty", "-m", "init")
+	run("worktree", "add", wtDir, "-b", "feature")
+
+	// cwd is the main checkout throughout, as it is for an agent hook.
+	t.Chdir(mainDir)
+
+	tests := []struct {
+		name        string
+		dir         string
+		wantGitDir  string
+		wantRoot    string
+		errNotARepo bool
+	}{
+		{
+			name:       "main checkout",
+			dir:        mainDir,
+			wantGitDir: filepath.Join(mainDir, ".git"),
+			wantRoot:   mainDir,
+		},
+		{
+			name:       "worktree nested in the main checkout",
+			dir:        wtDir,
+			wantGitDir: filepath.Join(mainDir, ".git", "worktrees", "feature"),
+			wantRoot:   wtDir,
+		},
+		{
+			// A Write creating a file in a new directory: the directory does
+			// not exist yet when the pre-tool-use hook runs.
+			name:       "not yet created directory inside a worktree",
+			dir:        filepath.Join(wtDir, "new", "pkg"),
+			wantGitDir: filepath.Join(mainDir, ".git", "worktrees", "feature"),
+			wantRoot:   wtDir,
+		},
+		{
+			name:        "outside any repository",
+			dir:         t.TempDir(),
+			errNotARepo: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			gitDir, root, err := FindGitDirAndRootFrom(tc.dir)
+			if tc.errNotARepo {
+				assert.ErrorIs(t, err, ErrNotARepository)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tc.wantGitDir, gitDir)
+			assert.Equal(t, tc.wantRoot, root)
+		})
+	}
+}

app/cli/internal/trace/provider.go

@@ -54,7 +54,10 @@ type Provider interface {
 	// CopySessionData copies the agent's on-disk session artifacts into
 	// the store's raw/ directory so pre-push can parse them independently of
 	// the agent's own storage (which may be rotated/cleaned later).
-	CopySessionData(store *state.Store, repoRoot, sessionID string) error
+	// agentCwd is the directory the session runs in, which decides where the
+	// agent keeps its transcripts; it need not be the checkout that owns
+	// store.
+	CopySessionData(store *state.Store, agentCwd, sessionID string) error
 
 	// CaptureFileSnapshot is invoked from the pre-edit hook to record any
 	// state the provider needs to later reconstruct the file's pre-edit
@@ -132,6 +135,11 @@ type HookInput struct {
 	ToolName string `json:"tool_name,omitempty"`
 	// FilePath is the absolute path of the file being edited, set by provider's ReadHookInput.
 	FilePath string `json:"-"`
+	// Cwd is the directory the agent session runs in, which is where the
+	// agent files its transcripts. It can differ from the checkout that owns
+	// FilePath, e.g. for an edit in a linked git worktree. Empty when the
+	// agent does not report it.
+	Cwd string `json:"cwd,omitempty"`
 	// AgentVersion is the agent runtime version reported in the hook payload
 	// (e.g., Cursor's cursor_version). Captured at session-start so parsing
 	// can set Agent.Version even when the transcript itself doesn't carry it.

app/cli/internal/trace/state/locate.go

@@ -42,28 +42,39 @@ import (
 // binding such a clone to an ancestor's out-of-tree state would silently
 // record its commits nowhere.
 func Locate() (store *Store, root string, err error) {
-	gitDir, repoRoot, err := tracegit.FindGitDirAndRoot()
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, "", fmt.Errorf("get working directory: %w", err)
+	}
+
+	return LocateFrom(cwd)
+}
+
+// LocateFrom is Locate starting from dir instead of cwd. Agent hooks use it to
+// file an edit under the checkout that owns the edited file: they run from the
+// directory the session started in, which for a file in a linked git worktree
+// is a different checkout with its own state (PFM-7412).
+func LocateFrom(start string) (store *Store, root string, err error) {
+	gitDir, repoRoot, err := tracegit.FindGitDirAndRootFrom(start)
 	switch {
 	case err == nil:
 		return NewGitStore(gitDir), repoRoot, nil
 	case !errors.Is(err, tracegit.ErrNotARepository):
 		return nil, "", err
 	}
 
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, "", fmt.Errorf("get working directory: %w", err)
-	}
-
 	base, err := nonGitBase()
 	if err != nil {
 		return nil, "", err
 	}
 
-	for dir := resolveDir(cwd); ; {
+	for dir := resolveDir(start); ; {
 		candidate := NewOutOfTreeStore(filepath.Join(base, hashDir(dir)))
 		if candidate.IsTraceRunActive() {
-			return candidate, dir, nil
+			// start may name a directory that does not exist yet (a file
+			// about to be created), which resolveDir cannot canonicalize;
+			// the ancestor holding the run does exist, so resolve it here.
+			return candidate, resolveDir(dir), nil
 		}
 
 		parent := filepath.Dir(dir)
@@ -73,7 +84,7 @@ func Locate() (store *Store, root string, err error) {
 		dir = parent
 	}
 
-	return nil, "", fmt.Errorf("not a git repository and no active chainloop trace run found from %q up to root", cwd)
+	return nil, "", fmt.Errorf("not a git repository and no active chainloop trace run found from %q up to root", start)
 }
 
 // NonGitDir returns the out-of-tree directory that parents trace state for a

app/cli/internal/trace/state/locate_test.go

@@ -167,3 +167,40 @@ func TestLocate(t *testing.T) {
 		assert.Error(t, err)
 	})
 }
+
+func TestLocateFrom(t *testing.T) {
+	t.Run("inside a git repository ignores cwd", func(t *testing.T) {
+		isolateCacheDir(t)
+
+		repo := t.TempDir()
+		require.NoError(t, os.MkdirAll(filepath.Join(repo, ".git"), 0755))
+		other := t.TempDir()
+		require.NoError(t, os.MkdirAll(filepath.Join(other, ".git"), 0755))
+		t.Chdir(other)
+
+		store, root, err := LocateFrom(filepath.Join(repo, "sub"))
+		require.NoError(t, err)
+		assert.True(t, store.IsGit())
+		assert.Equal(t, repo, root)
+		assert.Equal(t, filepath.Join(repo, ".git"), store.GitDir())
+	})
+
+	t.Run("no repository binds to the active run above dir", func(t *testing.T) {
+		isolateCacheDir(t)
+
+		dir := t.TempDir()
+		want, err := NonGitDir(dir)
+		require.NoError(t, err)
+		wantStore := NewOutOfTreeStore(want)
+		require.NoError(t, wantStore.InitTraceDir())
+		require.NoError(t, wantStore.MarkTraceRunActive())
+
+		t.Chdir(t.TempDir())
+
+		store, root, err := LocateFrom(filepath.Join(dir, "a", "b"))
+		require.NoError(t, err)
+		assert.False(t, store.IsGit())
+		assert.Equal(t, want, store.Dir())
+		assert.Equal(t, resolveDir(dir), root)
+	})
+}