Add hook templates and auto-install mechanism for new users

Problem: New users don't have sync-golden-rules hook, so golden-rules.md
doesn't auto-sync with database.

Solution:
- Add .hooks-templates/ directory to version all hooks in git
- Create install-hooks.py to copy templates to ~/.claude/hooks/
- Create verify-hooks.py to check and auto-install missing hooks
- Hooks are installed automatically during setup and checkin

New users now get:
- Auto-syncing of golden rules (PostToolUse hook)
- Seamless experience with zero manual config
- Safety net via verify-hooks in checkin

Installation workflow:
1. User runs setup.sh -> hooks auto-installed
2. User runs /checkin -> verify-hooks ensures they're present
3. PostToolUse hook keeps markdown and database in sync

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

Author: Spacehunterz

.hooks-templates/PostToolUse/sync-golden-rules.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Post-tool hook: Auto-sync golden-rules.md to database
+
+Runs after every tool use. If golden-rules.md was modified, syncs to database.
+"""
+
+import sqlite3
+import re
+from pathlib import Path
+import hashlib
+import json
+from datetime import datetime
+
+STATE_FILE = Path.home() / '.claude/hooks/investigation-state.json'
+MARKDOWN_FILE = Path.home() / '.claude/emergent-learning/memory/golden-rules.md'
+DB_FILE = Path.home() / '.claude/emergent-learning/memory/index.db'
+
+def get_file_hash(filepath):
+    """Get SHA256 hash of file."""
+    try:
+        with open(filepath, 'rb') as f:
+            return hashlib.sha256(f.read()).hexdigest()
+    except:
+        return None
+
+def load_state():
+    """Load last known state."""
+    try:
+        if STATE_FILE.exists():
+            with open(STATE_FILE) as f:
+                return json.load(f)
+    except:
+        pass
+    return {}
+
+def save_state(state):
+    """Save current state."""
+    try:
+        STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with open(STATE_FILE, 'w') as f:
+            json.dump(state, f)
+    except:
+        pass
+
+def sync_golden_rules():
+    """Sync markdown to database."""
+    try:
+        # Read markdown
+        with open(MARKDOWN_FILE) as f:
+            content = f.read()
+        
+        golden_titles = re.findall(r'^## \d+\. (.+)$', content, re.MULTILINE)
+        
+        # Connect to database
+        conn = sqlite3.connect(str(DB_FILE))
+        cur = conn.cursor()
+        
+        # Get all active heuristics
+        cur.execute('SELECT id, rule, is_golden FROM heuristics WHERE status="active"')
+        all_heuristics = cur.fetchall()
+        
+        updates = 0
+        for heuristic_id, rule_text, is_golden in all_heuristics:
+            should_be_golden = any(
+                title.lower() in rule_text.lower() 
+                for title in golden_titles
+            )
+            
+            if should_be_golden != bool(is_golden):
+                cur.execute('UPDATE heuristics SET is_golden=? WHERE id=?', 
+                           (1 if should_be_golden else 0, heuristic_id))
+                updates += 1
+        
+        conn.commit()
+        conn.close()
+        
+        return updates > 0
+    except Exception as e:
+        print(f"[WARN] Golden rules sync failed: {e}")
+        return False
+
+def run():
+    """Check if sync is needed and run it."""
+    state = load_state()
+    current_hash = get_file_hash(MARKDOWN_FILE)
+    last_hash = state.get('golden_rules_hash')
+    
+    # If markdown changed, sync to database
+    if current_hash and current_hash != last_hash:
+        if sync_golden_rules():
+            state['golden_rules_hash'] = current_hash
+            state['golden_rules_last_sync'] = datetime.now().isoformat()
+            save_state(state)
+            return "Synced golden-rules.md to database"
+    
+    return None
+
+if __name__ == '__main__':
+    result = run()
+    if result:
+        print(f"[SYNC] {result}")

.hooks-templates/README.md

@@ -0,0 +1,94 @@
+# ELF Hook Templates
+
+This directory contains templates for Claude Code hooks that enhance the ELF experience.
+
+## Hooks Included
+
+### PostToolUse/sync-golden-rules.py
+**Purpose:** Auto-sync golden-rules.md with the database after each tool use
+
+**What it does:**
+- Detects changes to `memory/golden-rules.md`
+- Syncs rule definitions to the heuristics database
+- Keeps markdown and database in sync automatically
+
+**When it runs:** After every tool execution
+
+---
+
+## Installation
+
+### Automatic (Recommended)
+Hooks are installed automatically during:
+1. **Initial ELF setup**: `bash install.sh`
+2. **First checkin**: `/checkin` command
+3. **Manual install**: `python scripts/install-hooks.py`
+
+### Manual Installation
+```bash
+# Install all hooks
+python ~/.claude/emergent-learning/scripts/install-hooks.py
+
+# Install with verbose output
+python ~/.claude/emergent-learning/scripts/install-hooks.py --verbose
+
+# Force reinstall existing hooks
+python ~/.claude/emergent-learning/scripts/install-hooks.py --force
+```
+
+### Verification
+```bash
+# Check if all hooks are installed
+python ~/.claude/emergent-learning/scripts/verify-hooks.py
+```
+
+---
+
+## How Hooks Work
+
+Hooks are shell scripts that run at specific points in the Claude Code workflow:
+
+**Hook Locations:**
+- `~/.claude/hooks/PostToolUse/` - Run after tool execution
+- `~/.claude/hooks/PreToolUse/` - Run before tool execution
+- `~/.claude/hooks/UserPromptSubmit/` - Run after user message
+- `~/.claude/hooks/SessionEnd/` - Run at session end
+
+**Exit Codes:**
+- `0` - Success (hook output is captured)
+- `1+` - Failure (hook output is not captured)
+
+---
+
+## For New Users
+
+When you first run ELF:
+1. **Setup** automatically installs hooks
+2. **Checkin** verifies hooks are installed (safety net)
+3. **Auto-sync** starts working immediately
+
+No manual action needed!
+
+---
+
+## Troubleshooting
+
+**Hooks not running?**
+- Check they're executable: `ls -la ~/.claude/hooks/PostToolUse/`
+- Verify hooks directory exists: `ls ~/.claude/hooks/`
+- Reinstall: `python ~/.claude/emergent-learning/scripts/install-hooks.py --force`
+
+**Auto-sync not working?**
+- Check hook was installed: `ls ~/.claude/hooks/PostToolUse/sync-golden-rules.py`
+- Run verify script: `python ~/.claude/emergent-learning/scripts/verify-hooks.py`
+- Check permissions: `chmod +x ~/.claude/hooks/PostToolUse/sync-golden-rules.py`
+
+---
+
+## Developing New Hooks
+
+1. Create hook in `.hooks-templates/[HOOK_TYPE]/my-hook.py`
+2. Test locally in `~/.claude/hooks/[HOOK_TYPE]/`
+3. Commit to repo
+4. Users will auto-install on next setup/checkin
+