Complete hooks implementation with comprehensive features

- Add project-level settings support (.claude/settings.json)
- Implement regex-based dangerous command detection
- Add typed tool input parsing (BashToolInput, FileToolInput)
- Replace terminal-notifier with speech-only notifications
- Add contextual spoken messages for prompts and notifications
- Implement timeout handling for hook execution
- Add comprehensive goimports automation for Go files
- Support global, local, and project hook configurations
- Fix JSON field mapping to match Claude Code expectations
- Add extensive logging and error handling

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

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/settings.json

@@ -0,0 +1,81 @@
+{
+  "hooks": {
+    "Notification": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/jason/git/hooks/hooks run"
+          }
+        ]
+      }
+    ]
+  }
+}

README.md

@@ -99,11 +99,8 @@ This package includes several example hooks:
 - **Project Context**: Adds git branch and project type information
 
 ### Notification
-- **Visual Notifications**: Shows native macOS notifications via `terminal-notifier`
 - **Speech Notifications**: Uses macOS 'say' command to speak notifications aloud
 
-Note: Install `terminal-notifier` with `brew install terminal-notifier` for visual notifications.
-
 ## Testing Hooks
 
 Test individual hooks by piping JSON:

cmd/install.go

@@ -6,20 +6,26 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/spf13/cobra"
 	"github.com/imjasonh/hooks/internal/config"
+	"github.com/spf13/cobra"
 )
 
 var (
-	uninstall bool
+	uninstall  bool
+	global     bool
+	local      bool
 	installCmd = &cobra.Command{
 		Use:   "install",
 		Short: "Install hooks to Claude settings",
 		Long: `Install this binary as a hook handler in your Claude settings.
 
+By default, installs to project settings (.claude/settings.json in current directory).
+Use --global for user settings (~/.claude/settings.json).
+Use --local for local directory settings (./.claude/settings.json).
+
 This command will:
-1. Find or create ~/.claude/settings.json
-2. Add this binary to handle all hook events
+1. Find or create the appropriate settings.json file
+2. Add this binary to handle all hook events  
 3. Configure it to match all tools
 
 Use --uninstall to remove the hooks.`,
@@ -30,6 +36,9 @@ Use --uninstall to remove the hooks.`,
 func init() {
 	rootCmd.AddCommand(installCmd)
 	installCmd.Flags().BoolVar(&uninstall, "uninstall", false, "Remove hooks from Claude settings")
+	installCmd.Flags().BoolVar(&global, "global", false, "Install to global settings (~/.claude/settings.json)")
+	installCmd.Flags().BoolVar(&local, "local", false, "Install to local settings (./.claude/settings.json)")
+	installCmd.MarkFlagsMutuallyExclusive("global", "local")
 }
 
 func runInstall(cmd *cobra.Command, args []string) error {
@@ -43,32 +52,43 @@ func runInstall(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to get absolute path: %w", err)
 	}
 
+	// Determine settings path based on flags
+	var settingsPath string
+	var scope string
+	if global {
+		settingsPath = config.GetGlobalSettingsPath()
+		scope = "global"
+	} else if local {
+		settingsPath = config.GetLocalSettingsPath()
+		scope = "local"
+	} else {
+		settingsPath = config.GetProjectSettingsPath()
+		scope = "project"
+	}
+
 	if uninstall {
-		slog.Info("uninstalling hooks", "binary", executable)
-		if err := config.UninstallHooks(executable); err != nil {
+		slog.Info("uninstalling hooks", "binary", executable, "scope", scope)
+		if err := config.UninstallHooksFromPath(executable, settingsPath); err != nil {
 			return fmt.Errorf("failed to uninstall hooks: %w", err)
 		}
-		fmt.Println("✓ Hooks uninstalled successfully")
+		fmt.Printf("✓ Hooks uninstalled successfully from %s settings\n", scope)
 		return nil
 	}
 
-	slog.Info("installing hooks", "binary", executable)
-	if err := config.InstallHooks(executable); err != nil {
+	slog.Info("installing hooks", "binary", executable, "scope", scope)
+	if err := config.InstallHooksToPath(executable, settingsPath); err != nil {
 		return fmt.Errorf("failed to install hooks: %w", err)
 	}
 
-	settingsPath := config.GetSettingsPath()
-	fmt.Printf("✓ Hooks installed successfully\n")
+	fmt.Printf("✓ Hooks installed successfully to %s settings\n", scope)
 	fmt.Printf("  Binary: %s\n", executable)
 	fmt.Printf("  Settings: %s\n", settingsPath)
 	fmt.Printf("\nThe following hooks are now active:\n")
 	fmt.Println("  • pre_tool_use: Validates bash commands and prevents sensitive file edits")
 	fmt.Println("  • post_tool_use: Logs tool usage and runs goimports on modified Go files")
 	fmt.Println("  • user_prompt_submit: Adds project context to prompts")
-	fmt.Println("  • notification: Shows notifications and speaks them aloud (macOS)")
-	fmt.Println("\nOptional: Install terminal-notifier for visual notifications:")
-	fmt.Println("  brew install terminal-notifier")
+	fmt.Println("  • notification: Speaks notifications aloud (macOS)")
 	fmt.Println("\nTo test: echo '{\"event\":\"pre_tool_use\",\"tool\":\"Bash\",\"tool_use_request\":{\"tool\":\"Bash\",\"parameters\":{\"command\":\"ls\"}}}' | hooks run")
 
 	return nil
-}
+}

internal/config/settings.go

@@ -8,13 +8,18 @@ import (
 )
 
 type Settings struct {
-	Hooks []Hook `json:"hooks"`
+	Hooks map[string][]HookDefinition `json:"hooks"`
 }
 
-type Hook struct {
-	Events   []string `json:"events"`
-	Matchers []string `json:"matchers"`
-	Cmds     []string `json:"cmds"`
+type HookDefinition struct {
+	Matcher string       `json:"matcher"`
+	Hooks   []HookAction `json:"hooks"`
+}
+
+type HookAction struct {
+	Type    string `json:"type"`
+	Command string `json:"command"`
+	Timeout int    `json:"timeout,omitempty"`
 }
 
 func LoadSettings(path string) (*Settings, error) {
@@ -53,74 +58,133 @@ func SaveSettings(path string, settings *Settings) error {
 }
 
 func GetSettingsPath() string {
+	return GetGlobalSettingsPath()
+}
+
+func GetGlobalSettingsPath() string {
 	if path := os.Getenv("CLAUDE_SETTINGS_PATH"); path != "" {
 		return path
 	}
-	
+
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return ""
 	}
-	
+
 	return filepath.Join(home, ".claude", "settings.json")
 }
 
+func GetLocalSettingsPath() string {
+	return filepath.Join(".", ".claude", "settings.local.json")
+}
+
+func GetProjectSettingsPath() string {
+	return filepath.Join(".", ".claude", "settings.json")
+}
+
 func InstallHooks(binaryPath string) error {
-	settingsPath := GetSettingsPath()
+	return InstallHooksToPath(binaryPath, GetSettingsPath())
+}
+
+func InstallHooksToPath(binaryPath, settingsPath string) error {
 	settings, err := LoadSettings(settingsPath)
 	if err != nil {
 		return err
 	}
 
+	if settings.Hooks == nil {
+		settings.Hooks = make(map[string][]HookDefinition)
+	}
+
 	hookCmd := binaryPath + " run"
-	
-	allEvents := []string{
-		"pre_tool_use",
-		"post_tool_use", 
-		"user_prompt_submit",
-		"stop",
-		"subagent_stop",
-		"notification",
-		"pre_compact",
+	hookAction := HookAction{
+		Type:    "command",
+		Command: hookCmd,
 	}
 
-	found := false
-	for i, hook := range settings.Hooks {
-		if len(hook.Cmds) > 0 && hook.Cmds[0] == hookCmd {
-			settings.Hooks[i].Events = allEvents
-			settings.Hooks[i].Matchers = []string{".*"}
-			found = true
-			break
+	hookDef := HookDefinition{
+		Matcher: ".*",
+		Hooks:   []HookAction{hookAction},
+	}
+
+	// Map our event names to Claude's event names
+	eventMap := map[string]string{
+		"pre_tool_use":       "PreToolUse",
+		"post_tool_use":      "PostToolUse",
+		"user_prompt_submit": "UserPromptSubmit",
+		"stop":               "Stop",
+		"subagent_stop":      "SubagentStop",
+		"notification":       "Notification",
+		"pre_compact":        "PreCompact",
+	}
+
+	for _, claudeEvent := range eventMap {
+		// Check if our hook is already installed
+		found := false
+		for i, def := range settings.Hooks[claudeEvent] {
+			for j, action := range def.Hooks {
+				if action.Command == hookCmd {
+					// Update existing hook
+					settings.Hooks[claudeEvent][i].Hooks[j] = hookAction
+					found = true
+					break
+				}
+			}
+			if found {
+				break
+			}
 		}
-	}
 
-	if !found {
-		settings.Hooks = append(settings.Hooks, Hook{
-			Events:   allEvents,
-			Matchers: []string{".*"},
-			Cmds:     []string{hookCmd},
-		})
+		if !found {
+			// Add new hook
+			settings.Hooks[claudeEvent] = append(settings.Hooks[claudeEvent], hookDef)
+		}
 	}
 
 	return SaveSettings(settingsPath, settings)
 }
 
 func UninstallHooks(binaryPath string) error {
-	settingsPath := GetSettingsPath()
+	return UninstallHooksFromPath(binaryPath, GetSettingsPath())
+}
+
+func UninstallHooksFromPath(binaryPath, settingsPath string) error {
 	settings, err := LoadSettings(settingsPath)
 	if err != nil {
 		return err
 	}
 
+	if settings.Hooks == nil {
+		return nil
+	}
+
 	hookCmd := binaryPath + " run"
-	filtered := make([]Hook, 0)
-	
-	for _, hook := range settings.Hooks {
-		if len(hook.Cmds) == 0 || hook.Cmds[0] != hookCmd {
-			filtered = append(filtered, hook)
+
+	// Remove our hook from all events
+	for eventName, hookDefs := range settings.Hooks {
+		newDefs := make([]HookDefinition, 0)
+
+		for _, def := range hookDefs {
+			newActions := make([]HookAction, 0)
+			for _, action := range def.Hooks {
+				if action.Command != hookCmd {
+					newActions = append(newActions, action)
+				}
+			}
+
+			// Only keep the definition if it still has actions
+			if len(newActions) > 0 {
+				def.Hooks = newActions
+				newDefs = append(newDefs, def)
+			}
+		}
+
+		if len(newDefs) > 0 {
+			settings.Hooks[eventName] = newDefs
+		} else {
+			delete(settings.Hooks, eventName)
 		}
 	}
 
-	settings.Hooks = filtered
 	return SaveSettings(settingsPath, settings)
-}
+}

internal/handlers/goimports.go

@@ -14,44 +14,48 @@ func init() {
 }
 
 func RunGoImportsOnGoFiles(ctx context.Context, input hooks.HookInput) (hooks.HookOutput, error) {
-	// Extract file path from parameters
-	filePath, ok := input.ToolUseRequest.Parameters["file_path"].(string)
-	if !ok {
-		return hooks.HookOutput{Decision: "continue"}, nil
+	fileInput, err := input.GetFileInput()
+	if err != nil {
+		slog.Debug("no file input found", "error", err)
+		return hooks.HookOutput{Decision: "approve"}, nil
+	}
+
+	if fileInput.FilePath == "" {
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
 	// Check if it's a Go file
-	if !strings.HasSuffix(filePath, ".go") {
-		return hooks.HookOutput{Decision: "continue"}, nil
+	if !strings.HasSuffix(fileInput.FilePath, ".go") {
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
 	// Check if goimports is available
 	if _, err := exec.LookPath("goimports"); err != nil {
 		slog.Debug("goimports not found in PATH", "error", err)
-		return hooks.HookOutput{Decision: "continue"}, nil
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
 	// Run goimports -w on the file
-	cmd := exec.CommandContext(ctx, "goimports", "-w", filePath)
+	cmd := exec.CommandContext(ctx, "goimports", "-w", fileInput.FilePath)
 	output, err := cmd.CombinedOutput()
-	
+
 	if err != nil {
-		slog.Error("goimports failed", 
-			"file", filePath,
+		slog.Error("goimports failed",
+			"file", fileInput.FilePath,
 			"error", err,
 			"output", string(output))
 		// Don't block on goimports errors
-		return hooks.HookOutput{Decision: "continue"}, nil
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
 	if len(output) > 0 {
 		slog.Info("goimports applied changes",
-			"file", filePath,
+			"file", fileInput.FilePath,
 			"output", string(output))
 	} else {
 		slog.Info("goimports completed",
-			"file", filePath)
+			"file", fileInput.FilePath)
 	}
 
-	return hooks.HookOutput{Decision: "continue"}, nil
-}
+	return hooks.HookOutput{Decision: "approve"}, nil
+}

internal/handlers/notification.go

@@ -18,59 +18,42 @@ func init() {
 func SpeakNotification(ctx context.Context, input hooks.HookInput) (hooks.HookOutput, error) {
 	// Only run on macOS
 	if runtime.GOOS != "darwin" {
-		return hooks.HookOutput{Decision: "continue"}, nil
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
-	// Build the notification content
-	var title, message, subtitle string
-	if input.Notification.Permission != "" {
-		// Permission request
-		title = "Claude Permission Request"
-		subtitle = fmt.Sprintf("Tool: %s", input.Notification.Tool)
+	// Build the notification content for speech
+	var message string
+
+	// Check if we have the direct message format (newer)
+	if input.Message != "" {
+		message = input.Message
+	} else if input.Notification.Permission != "" {
+		// Permission request (older format)
 		message = fmt.Sprintf("Requesting permission to %s", input.Notification.Message)
-	} else {
-		// Regular notification
-		title = "Claude Notification"
-		subtitle = fmt.Sprintf("Tool: %s", input.Notification.Tool)
+	} else if input.Notification.Message != "" {
+		// Regular notification (older format)
 		message = input.Notification.Message
-	}
-
-	// Show notification using terminal-notifier if available
-	if _, err := exec.LookPath("terminal-notifier"); err == nil {
-		args := []string{
-			"-title", title,
-			"-subtitle", subtitle,
-			"-message", message,
-			"-sound", "default",
-			"-group", "claude-hooks",
-		}
-		
-		cmd := exec.CommandContext(ctx, "terminal-notifier", args...)
-		if err := cmd.Start(); err != nil {
-			slog.Error("failed to show notification", "error", err)
-		} else {
-			// Don't wait for completion
-			go func() {
-				if err := cmd.Wait(); err != nil {
-					slog.Debug("terminal-notifier failed", "error", err)
-				}
-			}()
-			slog.Info("showed notification",
-				"tool", input.Notification.Tool,
-				"permission", input.Notification.Permission != "")
-		}
 	} else {
-		slog.Debug("terminal-notifier not found, install with: brew install terminal-notifier")
+		// No valid notification content
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
-	// Also speak the notification if say is available
+	// Speak the notification using macOS say command
 	if _, err := exec.LookPath("say"); err == nil {
-		spokenMessage := fmt.Sprintf("%s. %s", subtitle, message)
-		
+		// Build more informative spoken message
+		var spokenMessage string
+		if input.Notification.Permission != "" {
+			spokenMessage = fmt.Sprintf("Claude is requesting permission for %s: %s", input.Notification.Tool, message)
+		} else if input.Notification.Tool != "" {
+			spokenMessage = fmt.Sprintf("Claude notification from %s: %s", input.Notification.Tool, message)
+		} else {
+			spokenMessage = fmt.Sprintf("Claude notification: %s", message)
+		}
+
 		// Sanitize for speech
 		spokenMessage = strings.ReplaceAll(spokenMessage, "\n", " ")
 		spokenMessage = strings.ReplaceAll(spokenMessage, "\"", "'")
-		
+
 		// Truncate if too long
 		if len(spokenMessage) > 200 {
 			spokenMessage = spokenMessage[:197] + "..."
@@ -86,8 +69,11 @@ func SpeakNotification(ctx context.Context, input hooks.HookInput) (hooks.HookOu
 					slog.Debug("say command failed", "error", err)
 				}
 			}()
+			slog.Info("spoke notification",
+				"tool", input.Notification.Tool,
+				"permission", input.Notification.Permission != "")
 		}
 	}
 
-	return hooks.HookOutput{Decision: "continue"}, nil
-}
+	return hooks.HookOutput{Decision: "approve"}, nil
+}

internal/handlers/posttooluse.go

@@ -42,5 +42,5 @@ func LogToolUsage(ctx context.Context, input hooks.HookInput) (hooks.HookOutput,
 			"timestamp", time.Now().Unix())
 	}
 
-	return hooks.HookOutput{Decision: "continue"}, nil
+	return hooks.HookOutput{Decision: "approve"}, nil
 }

internal/handlers/pretooluse.go

@@ -4,51 +4,68 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"regexp"
 	"strings"
 
 	"github.com/imjasonh/hooks/internal/hooks"
 )
 
-var dangerousCommands = []string{
-	"rm -rf /",
-	"rm -rf /*",
-	":(){ :|:& };:",
-	"mkfs.",
-	"dd if=/dev/zero",
-	"> /dev/sda",
-	"wget http",
-	"curl http",
+type DangerousPattern struct {
+	Pattern     *regexp.Regexp
+	Description string
+}
+
+var dangerousPatterns = []DangerousPattern{
+	{regexp.MustCompile(`rm\s+-rf\s+/[^a-zA-Z]`), "recursive deletion of root filesystem"},
+	{regexp.MustCompile(`rm\s+-rf\s+/\*`), "recursive deletion of root filesystem contents"},
+	{regexp.MustCompile(`:\(\)\{\s*:\|\:&\s*\};\:`), "fork bomb"},
+	{regexp.MustCompile(`mkfs\.`), "filesystem formatting"},
+	{regexp.MustCompile(`dd\s+if=/dev/zero`), "disk wiping with dd"},
+	{regexp.MustCompile(`>\s*/dev/sd[a-z]`), "writing directly to disk device"},
+	{regexp.MustCompile(`wget\s+https?://`), "downloading files from internet"},
+	{regexp.MustCompile(`curl\s+https?://`), "downloading files from internet"},
+	{regexp.MustCompile(`chmod\s+\+x.*\.(sh|py|pl).*&&.*\./`), "download and execute pattern"},
+	{regexp.MustCompile(`sudo\s+rm\s+-rf`), "privileged recursive deletion"},
+	{regexp.MustCompile(`>/etc/passwd`), "overwriting system password file"},
+	{regexp.MustCompile(`>/etc/shadow`), "overwriting system shadow file"},
 }
 
 func ValidateBashCommand(ctx context.Context, input hooks.HookInput) (hooks.HookOutput, error) {
-	cmd, ok := input.ToolUseRequest.Parameters["command"].(string)
-	if !ok {
-		return hooks.HookOutput{Decision: "continue"}, nil
+	bashInput, err := input.GetBashInput()
+	if err != nil {
+		slog.Debug("no bash input found", "error", err)
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
-	for _, dangerous := range dangerousCommands {
-		if strings.Contains(cmd, dangerous) {
+	if bashInput.Command == "" {
+		return hooks.HookOutput{Decision: "approve"}, nil
+	}
+
+	// Check against dangerous patterns
+	for _, pattern := range dangerousPatterns {
+		if pattern.Pattern.MatchString(bashInput.Command) {
 			slog.Warn("blocked dangerous command",
-				"command", cmd,
-				"pattern", dangerous)
+				"command", bashInput.Command,
+				"reason", pattern.Description)
 			return hooks.HookOutput{
 				Decision: "block",
-				Reason:   fmt.Sprintf("Command contains dangerous pattern: %s", dangerous),
+				Reason:   fmt.Sprintf("Command blocked: %s", pattern.Description),
 			}, nil
 		}
 	}
 
-	if strings.Contains(cmd, "sudo") && !strings.Contains(cmd, "sudo -n") {
+	// Modify sudo commands to be non-interactive
+	if strings.Contains(bashInput.Command, "sudo") && !strings.Contains(bashInput.Command, "sudo -n") {
 		slog.Info("modifying sudo command to non-interactive")
 		return hooks.HookOutput{
-			Decision: "continue",
-			ModifiedParameters: map[string]interface{}{
-				"command": strings.ReplaceAll(cmd, "sudo", "sudo -n"),
+			Decision: "approve",
+			ModifiedParameters: map[string]any{
+				"command": strings.ReplaceAll(bashInput.Command, "sudo", "sudo -n"),
 			},
 		}, nil
 	}
 
-	return hooks.HookOutput{Decision: "continue"}, nil
+	return hooks.HookOutput{Decision: "approve"}, nil
 }
 
 var sensitiveFiles = []string{
@@ -62,23 +79,28 @@ var sensitiveFiles = []string{
 }
 
 func PreventSensitiveFileEdits(ctx context.Context, input hooks.HookInput) (hooks.HookOutput, error) {
-	path, ok := input.ToolUseRequest.Parameters["file_path"].(string)
-	if !ok {
-		return hooks.HookOutput{Decision: "continue"}, nil
+	fileInput, err := input.GetFileInput()
+	if err != nil {
+		slog.Debug("no file input found", "error", err)
+		return hooks.HookOutput{Decision: "approve"}, nil
 	}
 
-	lowerPath := strings.ToLower(path)
+	if fileInput.FilePath == "" {
+		return hooks.HookOutput{Decision: "approve"}, nil
+	}
+
+	lowerPath := strings.ToLower(fileInput.FilePath)
 	for _, sensitive := range sensitiveFiles {
 		if strings.Contains(lowerPath, strings.ToLower(sensitive)) {
 			slog.Warn("blocked sensitive file edit",
-				"file", path,
+				"file", fileInput.FilePath,
 				"pattern", sensitive)
 			return hooks.HookOutput{
 				Decision: "block",
-				Reason:   fmt.Sprintf("Cannot edit sensitive file: %s", path),
+				Reason:   fmt.Sprintf("Cannot edit sensitive file: %s", fileInput.FilePath),
 			}, nil
 		}
 	}
 
-	return hooks.HookOutput{Decision: "continue"}, nil
-}
+	return hooks.HookOutput{Decision: "approve"}, nil
+}

internal/handlers/userprompt.go

@@ -5,18 +5,43 @@ import (
 	"fmt"
 	"log/slog"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/imjasonh/hooks/internal/hooks"
 )
 
 func AddProjectContext(ctx context.Context, input hooks.HookInput) (hooks.HookOutput, error) {
+	// Speak notification for hook event on macOS
+	if runtime.GOOS == "darwin" {
+		if _, err := exec.LookPath("say"); err == nil {
+			// Extract first few words from prompt for context
+			promptPreview := input.Prompt
+			if len(promptPreview) > 50 {
+				promptPreview = promptPreview[:47] + "..."
+			}
+			// Remove newlines for speech
+			promptPreview = strings.ReplaceAll(promptPreview, "\n", " ")
+
+			spokenMessage := fmt.Sprintf("User prompt received: %s", promptPreview)
+			cmd := exec.CommandContext(ctx, "say", "-v", "Samantha", spokenMessage)
+			if err := cmd.Start(); err == nil {
+				go func() {
+					if err := cmd.Wait(); err != nil {
+						slog.Debug("say command failed", "error", err)
+					}
+				}()
+			}
+		}
+	}
+
 	var contexts []string
 
 	if gitRoot := findGitRoot(input.CWD); gitRoot != "" {
 		contexts = append(contexts, fmt.Sprintf("Git repository root: %s", gitRoot))
-		
+
 		if branch := getCurrentBranch(gitRoot); branch != "" {
 			contexts = append(contexts, fmt.Sprintf("Current branch: %s", branch))
 		}
@@ -34,12 +59,12 @@ func AddProjectContext(ctx context.Context, input hooks.HookInput) (hooks.HookOu
 		additionalContext := "Project context:\n" + strings.Join(contexts, "\n")
 		slog.Info("adding project context", "context_lines", len(contexts))
 		return hooks.HookOutput{
-			Decision:          "continue",
+			Decision:          "approve",
 			AdditionalContext: additionalContext,
 		}, nil
 	}
 
-	return hooks.HookOutput{Decision: "continue"}, nil
+	return hooks.HookOutput{Decision: "approve"}, nil
 }
 
 func findGitRoot(dir string) string {
@@ -67,4 +92,4 @@ func getCurrentBranch(gitRoot string) string {
 		return strings.TrimPrefix(ref, "ref: refs/heads/")
 	}
 	return ""
-}
+}