fix(parser): attribute Git worktrees to repositories (#1294)

Activity reports currently fragment repository activity under short-lived worktree directory names when linked worktrees are backed by a bare Git repository or their checkout has already been removed.

This change derives live bare-backed repositories from the common Git directory without spawning Git, and recognizes standard hosted worktree layouts when Git metadata is unavailable. Tool-anchored manager layouts keep their explicit path precedence, while generic hosted patterns defer to a live enclosing repository so matching fixture or nested paths are not misattributed.

The parser data version advances so existing source-backed sessions are reparsed through the established non-destructive full-resync flow. Archived sessions whose original source is permanently unavailable are preserved, but their previous project attribution cannot be recomputed.

The main review points are the filesystem-only `core.bare` detection, the anchored-versus-generic layout precedence, and the data-version-triggered repair path.

Co-authored-by: Wes McKinney <wesm@users.noreply.github.com>

Author: wesm

internal/db/db.go

@@ -333,7 +333,13 @@ const projectIdentityRemoteScrubCompletedKey = "project_identity_remote_scrub_v1
 // (74: Claude Code IDE context reparse. Standalone ide_opened_file and
 // ide_selection wrappers are promoted to system metadata so existing
 // VS Code sessions no longer use them as titles or user turns.)
-const dataVersion = 74
+// (75: Git worktree project attribution reparse. Hosting-oriented worktree
+// paths retain the owning repository after checkout removal, live linked
+// worktrees backed by bare common repositories resolve to the repository
+// instead of the generated checkout leaf, and generic hosting fragments defer
+// to an enclosing live repository. Existing rows need re-parsing so activity
+// is neither fragmented by worktree names nor claimed by nested fixture paths.)
+const dataVersion = 75
 
 const tokenCoverageRepairStatsKey = "token_coverage_repair_v1"
 

internal/db/db_test.go

@@ -1008,9 +1008,9 @@ func TestMigration_ToolResultEventsTable(t *testing.T) {
 		"expected tool_result_events table after reopen")
 }
 
-func TestCurrentDataVersionClaudeIDEContext(t *testing.T) {
-	assert.Equal(t, 74, CurrentDataVersion(),
-		"Claude IDE context parsing requires a data version bump")
+func TestCurrentDataVersionGitWorktreeProjectAttribution(t *testing.T) {
+	assert.Equal(t, 75, CurrentDataVersion(),
+		"final git worktree project attribution requires a data version bump")
 }
 
 func TestInsertMessages_PreservesToolResultEvents(t *testing.T) {

internal/parser/project.go

@@ -115,10 +115,10 @@ func extractProjectFromCwdWithBranch(
 	}
 	cleaned := filepath.Clean(norm)
 
-	// Recognize worktree manager layouts before walking git roots.
-	// These layouts encode the owning project in the path even when
+	// Recognize tool-anchored worktree manager layouts before walking git
+	// roots. These layouts encode the owning project in the path even when
 	// the git root basename is a branch or generated worktree id.
-	if p := projectFromWorktreeLayout(cleaned); p != "" {
+	if p := projectFromAnchoredWorktreeLayout(cleaned); p != "" {
 		return NormalizeName(p)
 	}
 
@@ -137,6 +137,13 @@ func extractProjectFromCwdWithBranch(
 		}
 	}
 
+	// Generic hosting layouts are intentionally a fallback after live Git
+	// metadata. Otherwise a normal repository containing a matching fixture
+	// path would be attributed to the fixture's repository component.
+	if p := projectFromWorktreeLayout(cleaned); p != "" {
+		return NormalizeName(p)
+	}
+
 	name := filepath.Base(cleaned)
 	if isInvalidPathBase(name) {
 		return ""
@@ -156,6 +163,7 @@ type worktreeLayout struct {
 	projectPart         int
 	minParts            int
 	roborevCIBareLayout bool
+	gitFallbackOnly     bool
 }
 
 var worktreeLayouts []worktreeLayout
@@ -169,8 +177,21 @@ func init() {
 		{marker: sep + ".superset" + sep + "worktrees" + sep, projectPart: 0, minParts: 2},
 		// conductor/workspaces/$PROJECT/$BRANCH[/...]
 		{marker: sep + "conductor" + sep + "workspaces" + sep, projectPart: 0, minParts: 2},
-		// ~/.config/middleman/worktrees/github.com/$OWNER/$REPO/$WORKTREE[/...]
-		{marker: sep + ".config" + sep + "middleman" + sep + "worktrees" + sep + "github.com" + sep, projectPart: 1, minParts: 3},
+		// .../worktrees/github/github.com/$OWNER/$REPO/$WORKTREE[/...]
+		{
+			marker: sep + "worktrees" + sep + "github" + sep +
+				"github.com" + sep,
+			projectPart:     1,
+			minParts:        3,
+			gitFallbackOnly: true,
+		},
+		// .../worktrees/github.com/$OWNER/$REPO/$WORKTREE[/...]
+		{
+			marker:          sep + "worktrees" + sep + "github.com" + sep,
+			projectPart:     1,
+			minParts:        3,
+			gitFallbackOnly: true,
+		},
 		// ~/.codex/worktrees/$WORKTREE_ID/$REPO[/...]
 		{marker: sep + ".codex" + sep + "worktrees" + sep, projectPart: 1, minParts: 2},
 		// roborev CI: ~/.roborev/ci-worktrees/$REPO/roborev-ci-<jobID>-<id>[/...].
@@ -190,7 +211,18 @@ func init() {
 // directory layouts and extracts the project name component.
 // Returns "" if the path does not match any known layout.
 func projectFromWorktreeLayout(path string) string {
+	return projectFromWorktreeLayouts(path, true)
+}
+
+func projectFromAnchoredWorktreeLayout(path string) string {
+	return projectFromWorktreeLayouts(path, false)
+}
+
+func projectFromWorktreeLayouts(path string, includeGitFallbacks bool) string {
 	for _, layout := range worktreeLayouts {
+		if layout.gitFallbackOnly && !includeGitFallbacks {
+			continue
+		}
 		_, rest, found := strings.Cut(path, layout.marker)
 		if !found {
 			continue
@@ -702,6 +734,15 @@ func repoRootFromGitFile(repoDir, gitFilePath string) string {
 		if filepath.Base(commonDir) == ".git" {
 			return filepath.Dir(commonDir)
 		}
+		if gitConfigCoreBare(commonDir) {
+			// Bare repositories have no main checkout root. Return a
+			// conceptual sibling path so the caller can use its basename
+			// as the stable repository name.
+			name := strings.TrimSuffix(filepath.Base(commonDir), ".git")
+			if !isInvalidPathBase(name) {
+				return filepath.Join(filepath.Dir(commonDir), name)
+			}
+		}
 	}
 
 	// Fallback for linked worktrees if commondir is missing.
@@ -750,6 +791,52 @@ func readCommonDir(gitDir string) string {
 	return filepath.Clean(filepath.Join(gitDir, value))
 }
 
+func gitConfigCoreBare(gitDir string) bool {
+	b, err := os.ReadFile(filepath.Join(gitDir, "config"))
+	if err != nil {
+		return false
+	}
+
+	inCore := false
+	for raw := range strings.SplitSeq(string(b), "\n") {
+		line := strings.TrimSpace(raw)
+		if line == "" ||
+			strings.HasPrefix(line, "#") ||
+			strings.HasPrefix(line, ";") {
+			continue
+		}
+		if strings.HasPrefix(line, "[") {
+			end := strings.IndexByte(line, ']')
+			if end < 0 {
+				inCore = false
+				continue
+			}
+			section := strings.TrimSpace(line[1:end])
+			section, _, _ = strings.Cut(section, " ")
+			inCore = strings.EqualFold(section, "core")
+			continue
+		}
+		if !inCore {
+			continue
+		}
+
+		key, value, hasValue := strings.Cut(line, "=")
+		if !strings.EqualFold(strings.TrimSpace(key), "bare") {
+			continue
+		}
+		if !hasValue {
+			return true
+		}
+		switch strings.ToLower(strings.TrimSpace(value)) {
+		case "true", "yes", "on", "1":
+			return true
+		default:
+			return false
+		}
+	}
+	return false
+}
+
 func trimBranchSuffix(name, gitBranch string) string {
 	branch := strings.TrimSpace(gitBranch)
 	if name == "" || branch == "" {

internal/parser/project_git_test.go

@@ -106,6 +106,54 @@ func TestExtractProjectFromCwdWithBranchContext_GitWorktreeMainRoot(t *testing.T
 		"kit-backed worktree resolution should use the main repo name")
 }
 
+func TestExtractProjectFromCwd_BareBackedGitWorktree(t *testing.T) {
+	skipIfNoGit(t)
+
+	root := t.TempDir()
+	source := filepath.Join(root, "source")
+	bareRepo := filepath.Join(root, "shared", "sample-repo.git")
+	worktree := filepath.Join(root, "checkouts", "generated-leaf")
+	subdir := filepath.Join(worktree, "internal", "parser")
+
+	mustMkdirAll(t, source)
+	mustMkdirAll(t, filepath.Dir(bareRepo))
+	mustMkdirAll(t, filepath.Dir(worktree))
+	gitRun(t, source, "init", "-q", "-b", "main")
+	gitRun(t, source,
+		"-c", "user.email=test@example.com",
+		"-c", "user.name=Test User",
+		"-c", "commit.gpgsign=false",
+		"commit", "--allow-empty", "-q", "-m", "seed",
+	)
+	gitRun(t, root, "clone", "--bare", "-q", source, bareRepo)
+	gitRun(t, root,
+		"--git-dir", bareRepo,
+		"worktree", "add", "-q", "-b", "feature", worktree, "main",
+	)
+	mustMkdirAll(t, subdir)
+
+	assert.Equal(t, "sample_repo", ExtractProjectFromCwd(subdir))
+}
+
+func TestRepoRootFromGitFileDoesNotTreatNonBareCommonDirAsBare(
+	t *testing.T,
+) {
+	root := t.TempDir()
+	checkout := filepath.Join(root, "checkouts", "generated-leaf")
+	commonDir := filepath.Join(root, "shared", "sample-repo.git")
+	gitDir := filepath.Join(commonDir, "worktrees", "generated-leaf")
+	gitFile := filepath.Join(checkout, ".git")
+
+	mustMkdirAll(t, checkout)
+	mustMkdirAll(t, gitDir)
+	mustWriteFile(t, gitFile, "gitdir: "+gitDir+"\n")
+	mustWriteFile(t, filepath.Join(gitDir, "commondir"), "../..\n")
+	mustWriteFile(t, filepath.Join(commonDir, "config"),
+		"[core]\n\tbare = false\n")
+
+	assert.Equal(t, checkout, repoRootFromGitFile(checkout, gitFile))
+}
+
 func TestExtractProjectFromCwdPlainRepoDoesNotInvokeGit(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		t.Skip("test uses a POSIX shell git shim")
@@ -546,6 +594,88 @@ func TestExtractProjectFromCwdWithBranch_NestedWorktree(
 		"ExtractProjectFromCwdWithBranch(%q, %q)", deleted, "tauri-packaging")
 }
 
+func TestExtractProjectFromCwd_HostingWorktreeLayouts(t *testing.T) {
+	root := t.TempDir()
+	tests := []struct {
+		name  string
+		parts []string
+		want  string
+	}{
+		{
+			name: "HostingWorktree",
+			parts: []string{
+				"worktrees", "github.com", "example-org",
+				"sample-repo", "feature-branch",
+			},
+			want: "sample_repo",
+		},
+		{
+			name: "HostingWorktreeSubdirectory",
+			parts: []string{
+				"worktrees", "github.com", "example-org",
+				"sample-repo", "feature-branch", "internal", "parser",
+			},
+			want: "sample_repo",
+		},
+		{
+			name: "NamespacedHostingWorktree",
+			parts: []string{
+				"worktrees", "github", "github.com", "example-org",
+				"data-pipeline", "pr-17",
+			},
+			want: "data_pipeline",
+		},
+		{
+			name: "NamespacedHostingWorktreeSubdirectory",
+			parts: []string{
+				"worktrees", "github", "github.com", "example-org",
+				"data-pipeline", "pr-17", "cmd", "worker",
+			},
+			want: "data_pipeline",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cwd := filepath.Join(append([]string{root}, tt.parts...)...)
+			assert.Equal(t, tt.want, ExtractProjectFromCwd(cwd))
+		})
+	}
+}
+
+func TestExtractProjectFromCwd_HostingLayoutInsideGitRepoPrefersRepo(
+	t *testing.T,
+) {
+	root := t.TempDir()
+	repo := filepath.Join(root, "outer-repo")
+	cwd := filepath.Join(
+		repo, "worktrees", "github.com", "example-org",
+		"sample-repo", "fixture",
+	)
+
+	mustMkdirAll(t, filepath.Join(repo, ".git"))
+	mustMkdirAll(t, cwd)
+
+	assert.Equal(t, "outer_repo", ExtractProjectFromCwd(cwd))
+}
+
+func TestProjectFromWorktreeLayoutRequiresWorktreeLeaf(t *testing.T) {
+	root := t.TempDir()
+	tests := []string{
+		filepath.Join(
+			root, "worktrees", "github.com", "example-org", "sample-repo",
+		),
+		filepath.Join(
+			root, "worktrees", "github", "github.com",
+			"example-org", "sample-repo",
+		),
+	}
+
+	for _, path := range tests {
+		assert.Empty(t, projectFromWorktreeLayout(path), path)
+	}
+}
+
 func TestExtractProjectFromCwdWithBranch(t *testing.T) {
 	tests := []struct {
 		name   string