Fix post-commit hook not firing in linked worktrees (#500)

## Summary

- Resolve relative `core.hooksPath` values against the main repository
root instead of the worktree root, both in `GetHooksPath` (for roborev's
internal use) and via `EnsureAbsoluteHooksPath` (to fix the stored git
config so git itself dispatches hooks correctly from linked worktrees)
- Add JSONL post-commit hook logging to `~/.roborev/post-commit.log` so
that silent hook failures leave an audit trail (timestamp, repo,
outcome, reason)
- Preserve git tilde-expansion paths (`~`, `~/path`, `~user/path`)
during normalization
- Apply hooks-path normalization in `init`, `install-hook`, and
`uninstall-hook` as a fatal error so these commands stop before
operating on the wrong directory
- Clean up test anti-patterns in `internal/git/git_test.go`

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

cmd/roborev/hook.go

@@ -22,6 +22,9 @@ func installHookCmd() *cobra.Command {
 				return fmt.Errorf("not a git repository: %w", err)
 			}
 
+			if err := git.EnsureAbsoluteHooksPath(root); err != nil {
+				return fmt.Errorf("normalize hooks path: %w", err)
+			}
 			hooksDir, err := git.GetHooksPath(root)
 			if err != nil {
 				return fmt.Errorf("get hooks path: %w", err)

cmd/roborev/hook_test.go

@@ -9,6 +9,7 @@ import (
 	"net/http/httptest"
 	"net/url"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -454,3 +455,116 @@ func TestInitNoDaemonWithAgentCreatesCommentedRepoConfig(t *testing.T) {
 		}
 	}
 }
+
+func TestInstallHookFromLinkedWorktree(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("test uses Unix worktree semantics")
+	}
+
+	// Set up a main repo with a relative core.hooksPath but
+	// no hooks installed yet.
+	repo := testutil.NewTestRepoWithCommit(t)
+	customHooks := filepath.Join(repo.Root, ".githooks")
+	require.NoError(t, os.MkdirAll(customHooks, 0755))
+
+	runGit := func(dir string, args ...string) string {
+		t.Helper()
+		cmd := exec.Command("git", args...)
+		cmd.Dir = dir
+		cmd.Env = append(os.Environ(),
+			"GIT_AUTHOR_NAME=Test",
+			"GIT_AUTHOR_EMAIL=test@test.com",
+			"GIT_COMMITTER_NAME=Test",
+			"GIT_COMMITTER_EMAIL=test@test.com",
+		)
+		out, err := cmd.CombinedOutput()
+		require.NoError(t, err, "git %v: %s", args, out)
+		return strings.TrimSpace(string(out))
+	}
+
+	runGit(repo.Root, "config", "core.hooksPath", ".githooks")
+
+	// Create a linked worktree.
+	wtDir := t.TempDir()
+	resolved, err := filepath.EvalSymlinks(wtDir)
+	require.NoError(t, err)
+	runGit(repo.Root, "worktree", "add", resolved, "-b", "wt")
+
+	// Run install-hook from the worktree.
+	origDir, _ := os.Getwd()
+	require.NoError(t, os.Chdir(resolved))
+	t.Cleanup(func() { os.Chdir(origDir) })
+
+	installCmd := installHookCmd()
+	installCmd.SetArgs([]string{})
+	require.NoError(t, installCmd.Execute())
+
+	// The hooks should be installed in the main repo's .githooks.
+	for _, name := range []string{"post-commit", "post-rewrite"} {
+		_, err := os.Stat(filepath.Join(customHooks, name))
+		assert.NoError(t, err,
+			"%s should exist in shared hooks dir", name)
+	}
+}
+
+func TestUninstallHookFromLinkedWorktree(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("test uses Unix worktree semantics")
+	}
+
+	// Set up a main repo with a relative core.hooksPath and
+	// installed hooks.
+	repo := testutil.NewTestRepoWithCommit(t)
+	customHooks := filepath.Join(repo.Root, ".githooks")
+	require.NoError(t, os.MkdirAll(customHooks, 0755))
+
+	runGit := func(dir string, args ...string) string {
+		t.Helper()
+		cmd := exec.Command("git", args...)
+		cmd.Dir = dir
+		cmd.Env = append(os.Environ(),
+			"GIT_AUTHOR_NAME=Test",
+			"GIT_AUTHOR_EMAIL=test@test.com",
+			"GIT_COMMITTER_NAME=Test",
+			"GIT_COMMITTER_EMAIL=test@test.com",
+		)
+		out, err := cmd.CombinedOutput()
+		require.NoError(t, err, "git %v: %s", args, out)
+		return strings.TrimSpace(string(out))
+	}
+
+	// Set relative core.hooksPath, install hooks.
+	runGit(repo.Root, "config", "core.hooksPath", ".githooks")
+	for _, name := range []string{"post-commit", "post-rewrite"} {
+		var content string
+		if name == "post-commit" {
+			content = githook.GeneratePostCommit()
+		} else {
+			content = githook.GeneratePostRewrite()
+		}
+		require.NoError(t, os.WriteFile(
+			filepath.Join(customHooks, name),
+			[]byte(content), 0755))
+	}
+
+	// Create a linked worktree.
+	wtDir := t.TempDir()
+	resolved, err := filepath.EvalSymlinks(wtDir)
+	require.NoError(t, err)
+	runGit(repo.Root, "worktree", "add", resolved, "-b", "wt")
+
+	// Run uninstall-hook from the worktree.
+	origDir, _ := os.Getwd()
+	require.NoError(t, os.Chdir(resolved))
+	t.Cleanup(func() { os.Chdir(origDir) })
+
+	cmd := uninstallHookCmd()
+	require.NoError(t, cmd.Execute())
+
+	// The hooks in the main repo's .githooks should be removed.
+	for _, name := range []string{"post-commit", "post-rewrite"} {
+		_, err := os.Stat(filepath.Join(customHooks, name))
+		assert.ErrorIs(t, err, fs.ErrNotExist,
+			"%s should be removed from shared hooks dir", name)
+	}
+}

cmd/roborev/init_cmd.go

@@ -65,6 +65,9 @@ func initCmd() *cobra.Command {
 			}
 
 			// 4. Install hooks (post-commit + post-rewrite)
+			if err := git.EnsureAbsoluteHooksPath(root); err != nil {
+				return fmt.Errorf("normalize hooks path: %w", err)
+			}
 			hooksDir, err := git.GetHooksPath(root)
 			if err != nil {
 				return fmt.Errorf("get hooks path: %w", err)

cmd/roborev/postcommit.go

@@ -3,10 +3,14 @@ package main
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
+	"os"
+	"path/filepath"
 	"time"
 
+	"github.com/roborev-dev/roborev/internal/config"
 	"github.com/roborev-dev/roborev/internal/daemon"
 	"github.com/roborev-dev/roborev/internal/git"
 	"github.com/spf13/cobra"
@@ -16,6 +20,9 @@ import (
 // ensures hooks never block commits if the daemon stalls.
 var hookHTTPClient = &http.Client{Timeout: 3 * time.Second}
 
+// hookLogPath can be overridden in tests.
+var hookLogPath = ""
+
 func postCommitCmd() *cobra.Command {
 	var (
 		repoPath   string
@@ -35,15 +42,20 @@ func postCommitCmd() *cobra.Command {
 
 			root, err := git.GetRepoRoot(repoPath)
 			if err != nil {
-				return nil // Not a repo — silent exit for hooks
+				hookLog(repoPath, "skip", "not a git repo")
+				return nil
 			}
 
 			if git.IsRebaseInProgress(root) {
+				hookLog(root, "skip", "rebase in progress")
 				return nil
 			}
 
 			if err := ensureDaemon(); err != nil {
-				return nil // Can't reach daemon — don't block commit
+				hookLog(root, "fail", fmt.Sprintf(
+					"daemon unavailable: %v", err,
+				))
+				return nil
 			}
 
 			var gitRef string
@@ -67,11 +79,26 @@ func postCommitCmd() *cobra.Command {
 				bytes.NewReader(reqBody),
 			)
 			if err != nil {
-				return nil // Network error — don't block commit
+				hookLog(root, "fail", fmt.Sprintf(
+					"enqueue request failed: %v", err,
+				))
+				return nil
 			}
 			defer resp.Body.Close()
-			_, _ = io.Copy(io.Discard, resp.Body)
 
+			body, _ := io.ReadAll(resp.Body)
+			if resp.StatusCode >= 400 {
+				hookLog(root, "fail", fmt.Sprintf(
+					"daemon returned %d: %s",
+					resp.StatusCode,
+					truncateBytes(body, 200),
+				))
+				return nil
+			}
+
+			hookLog(root, "ok", fmt.Sprintf(
+				"enqueued ref=%s branch=%s", gitRef, branchName,
+			))
 			return nil
 		},
 	}
@@ -106,3 +133,52 @@ func enqueueCmd() *cobra.Command {
 	cmd.Hidden = true
 	return cmd
 }
+
+// hookLog appends a single JSONL entry to the post-commit log.
+// Best-effort: errors are silently ignored so the hook never
+// blocks a commit.
+func hookLog(repo, outcome, message string) {
+	logPath := hookLogPath
+	if logPath == "" {
+		logPath = filepath.Join(
+			config.DataDir(), "post-commit.log",
+		)
+	}
+
+	entry := struct {
+		TS      string `json:"ts"`
+		Repo    string `json:"repo"`
+		Outcome string `json:"outcome"`
+		Message string `json:"message"`
+	}{
+		TS:      time.Now().Format(time.RFC3339),
+		Repo:    repo,
+		Outcome: outcome,
+		Message: message,
+	}
+	data, err := json.Marshal(entry)
+	if err != nil {
+		return
+	}
+	data = append(data, '\n')
+
+	if err := os.MkdirAll(filepath.Dir(logPath), 0700); err != nil {
+		return
+	}
+	f, err := os.OpenFile(
+		logPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600,
+	)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	_ = f.Chmod(0600)
+	_, _ = f.Write(data)
+}
+
+func truncateBytes(b []byte, max int) string {
+	if len(b) <= max {
+		return string(b)
+	}
+	return string(b[:max]) + "..."
+}

cmd/roborev/postcommit_test.go

@@ -137,6 +137,106 @@ func TestEnqueueRejectsPositionalArgs(t *testing.T) {
 
 }
 
+func TestPostCommitLogsSuccess(t *testing.T) {
+	repo, mux := setupTestEnvironment(t)
+	mockEnqueue(t, mux)
+
+	logFile := filepath.Join(t.TempDir(), "post-commit.log")
+	old := hookLogPath
+	hookLogPath = logFile
+	t.Cleanup(func() { hookLogPath = old })
+
+	repo.CommitFile("file.txt", "content", "initial commit")
+
+	_, _, err := executePostCommitCmd("--repo", repo.Dir)
+	require.NoError(t, err)
+
+	data, err := os.ReadFile(logFile)
+	require.NoError(t, err)
+	assert.Contains(t, string(data), `"outcome":"ok"`)
+	assert.Contains(t, string(data), `"repo"`)
+}
+
+func TestPostCommitLogsSkipNotARepo(t *testing.T) {
+	logFile := filepath.Join(t.TempDir(), "post-commit.log")
+	old := hookLogPath
+	hookLogPath = logFile
+	t.Cleanup(func() { hookLogPath = old })
+
+	dir := t.TempDir()
+	_, _, err := executePostCommitCmd("--repo", dir)
+	require.NoError(t, err)
+
+	data, err := os.ReadFile(logFile)
+	require.NoError(t, err)
+	assert.Contains(t, string(data), `"outcome":"skip"`)
+	assert.Contains(t, string(data), "not a git repo")
+}
+
+func TestPostCommitLogsSkipRebase(t *testing.T) {
+	repo, _ := setupTestEnvironment(t)
+	repo.CommitFile("file.txt", "content", "initial commit")
+
+	logFile := filepath.Join(t.TempDir(), "post-commit.log")
+	old := hookLogPath
+	hookLogPath = logFile
+	t.Cleanup(func() { hookLogPath = old })
+
+	// Simulate rebase in progress.
+	gitDir := strings.TrimSpace(repo.Run("rev-parse", "--git-dir"))
+	if !filepath.IsAbs(gitDir) {
+		gitDir = filepath.Join(repo.Dir, gitDir)
+	}
+	require.NoError(t, os.MkdirAll(
+		filepath.Join(gitDir, "rebase-merge"), 0755))
+
+	_, _, err := executePostCommitCmd("--repo", repo.Dir)
+	require.NoError(t, err)
+
+	data, err := os.ReadFile(logFile)
+	require.NoError(t, err)
+	assert.Contains(t, string(data), `"outcome":"skip"`)
+	assert.Contains(t, string(data), "rebase in progress")
+}
+
+func TestPostCommitLogsDaemonFailure(t *testing.T) {
+	logFile := filepath.Join(t.TempDir(), "post-commit.log")
+	old := hookLogPath
+	hookLogPath = logFile
+	t.Cleanup(func() { hookLogPath = old })
+
+	repo := newTestGitRepo(t)
+	repo.CommitFile("file.txt", "content", "initial")
+
+	// Point serverAddr at nothing so ensureDaemon fails.
+	patchServerAddr(t, "http://127.0.0.1:1")
+
+	_, _, err := executePostCommitCmd("--repo", repo.Dir)
+	require.NoError(t, err)
+
+	data, err := os.ReadFile(logFile)
+	require.NoError(t, err)
+	assert.Contains(t, string(data), `"outcome":"fail"`)
+	assert.Contains(t, string(data), "daemon")
+}
+
+func TestPostCommitLogsCreatesParentDir(t *testing.T) {
+	// Log path under a directory that doesn't exist yet,
+	// simulating a fresh install where ~/.roborev is absent.
+	logFile := filepath.Join(t.TempDir(), "subdir", "post-commit.log")
+	old := hookLogPath
+	hookLogPath = logFile
+	t.Cleanup(func() { hookLogPath = old })
+
+	dir := t.TempDir()
+	_, _, err := executePostCommitCmd("--repo", dir)
+	require.NoError(t, err)
+
+	data, err := os.ReadFile(logFile)
+	require.NoError(t, err, "log file should be created even when parent dir is absent")
+	assert.Contains(t, string(data), `"outcome":"skip"`)
+}
+
 // stallingRoundTripper blocks until the request context is
 // cancelled, then returns an error. This simulates a daemon
 // that accepts connections but never responds, without needing