kevglynn
diff --git a/‎cmd/bd/export_auto.go‎
Lines changed: 129 additions & 1 deletion b/‎cmd/bd/export_auto.go‎
Lines changed: 129 additions & 1 deletion
@@ -272,9 +272,137 @@ func saveExportAutoState(beadsDir string, state *exportAutoState) {
 	}
 }
 
-// gitAddFile stages a file in the enclosing git repo.
+// gitAddFile stages a file in the enclosing git repo. When called from
+// inside a git hook, it scrubs inherited GIT_* env vars (so git
+// rediscovers the repo from cwd rather than treating cmd.Dir as the
+// worktree root) and skips staging when the target is outside the hook's
+// worktree (the .beads/redirect case, where staging would pollute the
+// main repo's index). See GH#3311, scrubGitHookEnv, hookWorkTreeRoot.
 func gitAddFile(path string) error {
+	if wt := hookWorkTreeRoot(); wt != "" && !pathInsideDir(path, wt) {
+		// Running inside a hook AND target is outside the hook's worktree.
+		// Staging here would pollute a different repo's index; skip.
+		return nil
+	}
 	cmd := exec.Command("git", "add", path)
 	cmd.Dir = filepath.Dir(path)
+	cmd.Env = scrubGitHookEnv(os.Environ())
 	return cmd.Run()
 }
+
+// scrubGitHookEnv returns env with the GIT_* variables that can poison
+// git's repo/worktree auto-discovery or object-store resolution removed,
+// so git falls back to auto-discovery from cwd. The scrub is
+// unconditional: if a user has intentionally exported any of these vars
+// for scripting purposes, they will be stripped from the git-add child
+// process. That is the correct trade-off here; we never want beads'
+// auto-stage to honor a GIT_DIR pointing at an unrelated repo.
+//
+// Covered vars:
+//   - Repo/worktree discovery: GIT_DIR, GIT_WORK_TREE, GIT_COMMON_DIR,
+//     GIT_PREFIX, GIT_CEILING_DIRECTORIES, GIT_DISCOVERY_ACROSS_FILESYSTEM
+//   - Index routing: GIT_INDEX_FILE
+//   - Object routing: GIT_OBJECT_DIRECTORY, GIT_ALTERNATE_OBJECT_DIRECTORIES
+//   - Config injection (any GIT_CONFIG* — e.g. GIT_CONFIG_PARAMETERS set
+//     when the parent ran `git -c core.worktree=… commit`): the whole
+//     GIT_CONFIG namespace, which includes _COUNT, _KEY_n, _VALUE_n,
+//     _GLOBAL, _SYSTEM, _NOSYSTEM, and the legacy GIT_CONFIG itself.
+func scrubGitHookEnv(env []string) []string {
+	// The GIT_CONFIG prefix (no trailing "=") is intentional: it matches
+	// GIT_CONFIG=, GIT_CONFIG_COUNT=, GIT_CONFIG_KEY_n=, GIT_CONFIG_VALUE_n=,
+	// GIT_CONFIG_PARAMETERS=, GIT_CONFIG_GLOBAL=, GIT_CONFIG_SYSTEM=, and
+	// GIT_CONFIG_NOSYSTEM= — the whole family — in one entry. No standard
+	// git env var starts with GIT_CONFIG that we want to preserve.
+	prefixes := []string{
+		"GIT_DIR=",
+		"GIT_WORK_TREE=",
+		"GIT_INDEX_FILE=",
+		"GIT_COMMON_DIR=",
+		"GIT_PREFIX=",
+		"GIT_OBJECT_DIRECTORY=",
+		"GIT_ALTERNATE_OBJECT_DIRECTORIES=",
+		"GIT_CEILING_DIRECTORIES=",
+		"GIT_DISCOVERY_ACROSS_FILESYSTEM=",
+		"GIT_CONFIG",
+	}
+	out := make([]string, 0, len(env))
+	for _, e := range env {
+		skip := false
+		for _, p := range prefixes {
+			if strings.HasPrefix(e, p) {
+				skip = true
+				break
+			}
+		}
+		if !skip {
+			out = append(out, e)
+		}
+	}
+	return out
+}
+
+// hookWorkTreeRoot returns the root of the worktree whose git hook we
+// are running inside, based on the inherited GIT_DIR env var. Returns ""
+// when GIT_DIR is not set (the normal non-hook case) or cannot be
+// resolved to a work-tree.
+//
+// Resolution rules:
+//   - In a linked worktree, GIT_DIR points at main/.git/worktrees/<name>
+//     and that directory contains a "gitdir" file whose contents are the
+//     absolute path to the worktree's .git FILE. The worktree root is
+//     the parent of that .git file.
+//   - In a non-worktree, GIT_DIR is typically ".git" or "<repo>/.git";
+//     the worktree root is its parent.
+func hookWorkTreeRoot() string {
+	gitDir := os.Getenv("GIT_DIR")
+	if gitDir == "" {
+		return ""
+	}
+	var root string
+	if data, err := os.ReadFile(filepath.Join(gitDir, "gitdir")); err == nil {
+		if dotGit := strings.TrimSpace(string(data)); dotGit != "" {
+			root = filepath.Dir(dotGit)
+		}
+	}
+	if root == "" && filepath.Base(gitDir) == ".git" {
+		root = filepath.Dir(gitDir)
+	}
+	if root == "" {
+		return ""
+	}
+	abs, err := filepath.Abs(root)
+	if err != nil {
+		return ""
+	}
+	return abs
+}
+
+// pathInsideDir reports whether path is the same as dir or a descendant
+// of dir, after resolving symlinks on both sides. Returns false on any
+// resolution error (conservative: when in doubt, treat as outside).
+//
+// Resolves the PARENT of path rather than path itself, which handles the
+// common "target file does not yet exist" case: on macOS /tmp is a
+// symlink to /private/tmp, so asymmetric EvalSymlinks on a nonexistent
+// file vs its existing parent would otherwise produce a spurious false.
+// Callers (gitAddFile) always pass a path whose parent exists (either
+// beadsDir, which FindBeadsDir verified, or a directory just created by
+// the export write), so this single-level resolution is sufficient.
+func pathInsideDir(path, dir string) bool {
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return false
+	}
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return false
+	}
+	if r, err := filepath.EvalSymlinks(filepath.Dir(absPath)); err == nil {
+		absPath = filepath.Join(r, filepath.Base(absPath))
+	}
+	if r, err := filepath.EvalSymlinks(absDir); err == nil {
+		absDir = r
+	}
+	sep := string(filepath.Separator)
+	return absPath == absDir || strings.HasPrefix(absPath, absDir+sep)
+}