fix(cli): record AI sessions for edits in git worktrees (PFM-7412)

An agent runs its hooks from the directory where the session started.
When the agent edited a file in a linked git worktree, trace recorded the
edit in the state of the main checkout. The git hooks of the worktree read
only the state of the worktree. So the commits in the worktree did not get
the session, and pre-push sent no attestation.

Record each file edit in the state of the checkout that owns the file.
Save the working directory of the agent in the session record. Use it to
find the session transcript from any worktree.

Assisted-by: Claude Code
Signed-off-by: Jose I. Paris <jiparis@chainloop.dev>

Chainloop-Trace-Sessions: 1a5dee29-1a25-49e8-8e20-17ebb61dde56

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)
+	})
+}