feed-the-machine 1.0.0 → 1.2.0

package/hooks/ftm-event-logger.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+/**
+ * FTM Event Logger — PostToolUse hook
+ * Appends structured JSONL entries to ~/.claude/ftm-state/events.log
+ * Debounced: fires every 3rd tool use to avoid overhead
+ */
+
+import { readFileSync, appendFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const HOME = homedir();
+const STATE_DIR = join(HOME, '.claude', 'ftm-state');
+const LOG_PATH = join(STATE_DIR, 'events.log');
+const COUNTER_PATH = join(STATE_DIR, '.event-counter');
+const ARCHIVE_DIR = join(STATE_DIR, 'event-archives');
+const MAX_AGE_DAYS = 30;
+
+// Ensure directories exist
+if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+
+// Read stdin for hook input
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const hookData = JSON.parse(input);
+
+    // Debounce: only fire every 3rd tool use
+    let counter = 0;
+    try {
+      counter = parseInt(readFileSync(COUNTER_PATH, 'utf-8').trim(), 10) || 0;
+    } catch { /* first run */ }
+
+    counter++;
+    writeFileSync(COUNTER_PATH, String(counter));
+
+    if (counter % 3 !== 0) {
+      process.exit(0); // Skip this invocation
+    }
+
+    // Build log entry
+    const entry = {
+      timestamp: new Date().toISOString(),
+      event_type: 'tool_use',
+      tool_name: hookData.tool_name || 'unknown',
+      tool_input_keys: hookData.tool_input ? Object.keys(hookData.tool_input) : [],
+      session_id: process.env.CLAUDE_SESSION_ID || 'unknown',
+      skill_context: detectSkillContext(hookData),
+    };
+
+    // Append JSONL
+    appendFileSync(LOG_PATH, JSON.stringify(entry) + '\n');
+
+    // Log rotation: check once per 100 writes
+    if (counter % 100 === 0) {
+      rotateOldEntries();
+    }
+
+  } catch (e) {
+    // Never crash — logging failure should not block execution
+    process.exit(0);
+  }
+});
+
+function detectSkillContext(hookData) {
+  const toolName = hookData.tool_name || '';
+  if (toolName === 'Skill') return hookData.tool_input?.skill || 'unknown-skill';
+  if (toolName === 'Agent') return 'agent-dispatch';
+  return null;
+}
+
+function rotateOldEntries() {
+  try {
+    if (!existsSync(LOG_PATH)) return;
+
+    const lines = readFileSync(LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+    const cutoff = Date.now() - (MAX_AGE_DAYS * 24 * 60 * 60 * 1000);
+
+    const recent = [];
+    const archived = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (new Date(entry.timestamp).getTime() > cutoff) {
+          recent.push(line);
+        } else {
+          archived.push(line);
+        }
+      } catch {
+        recent.push(line); // Keep unparseable lines
+      }
+    }
+
+    if (archived.length > 0) {
+      if (!existsSync(ARCHIVE_DIR)) mkdirSync(ARCHIVE_DIR, { recursive: true });
+      const archivePath = join(ARCHIVE_DIR, `events-${new Date().toISOString().slice(0, 10)}.log`);
+      appendFileSync(archivePath, archived.join('\n') + '\n');
+      writeFileSync(LOG_PATH, recent.join('\n') + (recent.length > 0 ? '\n' : ''));
+    }
+  } catch {
+    // Rotation failure is non-critical
+  }
+}

package/hooks/ftm-map-autodetect.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# UserPromptSubmit hook: auto-detect unmapped projects when ftm skills are invoked.
+# Detects greenfield vs brownfield and injects instructions to bootstrap ftm-map.
+# Only fires once per project (writes .ftm-map/.offered marker).
+
+set -euo pipefail
+
+INPUT=$(cat)
+PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""' 2>/dev/null)
+
+# Quick exit if no prompt or jq unavailable
+[ -n "$PROMPT" ] || exit 0
+
+# Only fire on ftm-related invocations
+PROMPT_LOWER=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]')
+IS_FTM=false
+for trigger in "/ftm" "ftm-" "brainstorm" "research" "debug this" "audit" "deep dive" "investigate"; do
+  if [[ "$PROMPT_LOWER" == *"$trigger"* ]]; then
+    IS_FTM=true
+    break
+  fi
+done
+$IS_FTM || exit 0
+
+# Already mapped — nothing to do
+[ -f ".ftm-map/map.db" ] && exit 0
+
+# Already offered for this project — don't nag
+[ -f ".ftm-map/.offered" ] && exit 0
+
+# --- Greenfield vs Brownfield detection ---
+
+# Count source files (fast, capped at 500 to avoid slow ls on huge repos)
+SRC_COUNT=0
+if command -v find &>/dev/null; then
+  SRC_COUNT=$(find . -maxdepth 4 \
+    \( -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.tsx" \
+       -o -name "*.jsx" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" \
+       -o -name "*.java" -o -name "*.rb" -o -name "*.sh" -o -name "*.mjs" \
+       -o -name "*.cjs" \) \
+    -not -path "*/node_modules/*" \
+    -not -path "*/.venv/*" \
+    -not -path "*/__pycache__/*" \
+    -not -path "*/.git/*" \
+    -not -path "*/.worktrees/*" \
+    2>/dev/null | head -500 | wc -l | tr -d ' ')
+fi
+
+# Git history depth
+COMMIT_COUNT=0
+if git rev-parse --is-inside-work-tree &>/dev/null 2>&1; then
+  COMMIT_COUNT=$(git rev-list --count HEAD 2>/dev/null || echo "0")
+fi
+
+# Classify
+if [ "$SRC_COUNT" -le 5 ] && [ "$COMMIT_COUNT" -le 3 ]; then
+  PROJECT_TYPE="greenfield"
+  PROJECT_DESC="Greenfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Small enough to index instantly."
+elif [ "$SRC_COUNT" -le 50 ]; then
+  PROJECT_TYPE="small-brownfield"
+  PROJECT_DESC="Small brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Quick to index."
+elif [ "$SRC_COUNT" -le 200 ]; then
+  PROJECT_TYPE="medium-brownfield"
+  PROJECT_DESC="Medium brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Index takes ~30s."
+else
+  PROJECT_TYPE="large-brownfield"
+  PROJECT_DESC="Large brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Index may take 1-2 min."
+fi
+
+# Write marker so we don't ask again
+mkdir -p .ftm-map
+echo "$PROJECT_TYPE" > .ftm-map/.offered
+
+# Inject context
+cat <<EOJSON
+{
+  "additionalContext": "[ftm-map-autodetect] This project has no code knowledge graph yet (.ftm-map/map.db missing). ${PROJECT_DESC} Before proceeding with the ftm skill, bootstrap the map: run \`ftm-map/scripts/setup.sh\` then \`ftm-map/scripts/.venv/bin/python3 ftm-map/scripts/index.py --bootstrap .\` in the background. This enables structural queries (blast radius, dependency chains) and keeps INTENT.md/ARCHITECTURE.mmd in sync via the post-commit hook. If the user's request is time-sensitive, proceed with the skill and index in parallel."
+}
+EOJSON

package/hooks/ftm-pending-sync-check.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# UserPromptSubmit hook: checks for pending commit syncs from out-of-session commits
+
+PENDING_FILE="$HOME/.claude/ftm-state/.pending-commit-syncs"
+
+# Quick exit if no pending syncs
+[ -f "$PENDING_FILE" ] || { echo '{}'; exit 0; }
+[ -s "$PENDING_FILE" ] || { echo '{}'; exit 0; }
+
+# Count pending entries
+COUNT=$(wc -l < "$PENDING_FILE" | tr -d ' ')
+
+# Read all pending entries
+ENTRIES=$(cat "$PENDING_FILE")
+
+# Consume the file (mark as processed)
+rm -f "$PENDING_FILE"
+
+# Inject context
+cat <<EOJSON
+{"additionalContext": "There are $COUNT pending out-of-session commits that need ftm-map incremental sync. Run ftm-map incremental for each:\n$ENTRIES"}
+EOJSON

package/hooks/ftm-plan-gate.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# ftm-plan-gate.sh
+# PreToolUse hook for Edit/Write tools.
+#
+# Checks if a plan has been presented and approved for this session before
+# allowing code edits. If no plan marker exists and the session involves
+# a medium+ task (detected by ftm-state), injects additionalContext
+# telling Claude to stop and present a plan first.
+#
+# The marker file is created by Claude when it presents a plan — we check
+# for it here. If the marker doesn't exist but edits are happening, it
+# means Claude skipped the planning step.
+#
+# Hook: PreToolUse (matcher: Edit|Write)
+
+set -euo pipefail
+
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""')
+
+# Only gate Edit and Write tools
+if [[ "$TOOL_NAME" != "Edit" && "$TOOL_NAME" != "Write" ]]; then
+  exit 0
+fi
+
+STATE_DIR="$HOME/.claude/ftm-state"
+PLAN_MARKER="$STATE_DIR/.plan-presented"
+SESSION_MARKER="$STATE_DIR/.session-id"
+EDIT_COUNTER="$STATE_DIR/.edit-count"
+SKILL_FILES_DIR="$HOME/.claude/skills"
+
+# Get the file being edited
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""')
+
+# Always allow edits to: skill files, ftm-state, drafts, .gitignore, markdown docs
+# These are "meta" edits that happen during planning/setup, not code grinding
+if [[ "$FILE_PATH" == *".claude/skills/"* ]] || \
+   [[ "$FILE_PATH" == *".claude/ftm-state/"* ]] || \
+   [[ "$FILE_PATH" == *".ftm-drafts/"* ]] || \
+   [[ "$FILE_PATH" == *".gitignore" ]] || \
+   [[ "$FILE_PATH" == *"INTENT.md"* ]] || \
+   [[ "$FILE_PATH" == *"ARCHITECTURE.mmd"* ]] || \
+   [[ "$FILE_PATH" == *"STYLE.md"* ]] || \
+   [[ "$FILE_PATH" == *"DEBUG.md"* ]] || \
+   [[ "$FILE_PATH" == *"PROGRESS.md"* ]] || \
+   [[ "$FILE_PATH" == *"CLAUDE.md"* ]]; then
+  exit 0
+fi
+
+# If plan marker exists and matches current session, allow
+CURRENT_SESSION="${CLAUDE_SESSION_ID:-unknown}"
+if [[ -f "$PLAN_MARKER" ]]; then
+  MARKER_SESSION=$(cat "$PLAN_MARKER" 2>/dev/null || echo "")
+  if [[ "$MARKER_SESSION" == "$CURRENT_SESSION" ]]; then
+    exit 0  # Plan was presented this session, allow edits
+  fi
+fi
+
+# Count edits this session (without a plan marker)
+EDIT_COUNT=0
+if [[ -f "$EDIT_COUNTER" ]]; then
+  STORED=$(cat "$EDIT_COUNTER" 2>/dev/null || echo "0:unknown")
+  STORED_SESSION=$(echo "$STORED" | cut -d: -f2)
+  if [[ "$STORED_SESSION" == "$CURRENT_SESSION" ]]; then
+    EDIT_COUNT=$(echo "$STORED" | cut -d: -f1)
+  fi
+fi
+
+EDIT_COUNT=$((EDIT_COUNT + 1))
+echo "${EDIT_COUNT}:${CURRENT_SESSION}" > "$EDIT_COUNTER"
+
+# First 2 edits get a warning injected as context (don't block — could be micro tasks)
+# After 3+ edits without a plan marker, escalate the warning
+if [[ $EDIT_COUNT -le 2 ]]; then
+  # Soft reminder — inject context but allow
+  cat <<'JSON'
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "additionalContext": "[ftm-plan-gate] You are editing files without having presented a plan this session. If this task is medium+ (touches 3+ files, involves external systems, or has stakeholder coordination), you MUST present a numbered plan and get user approval BEFORE editing code. If this is a micro/small task, you can proceed — but create the plan marker by writing the current session ID to ~/.claude/ftm-state/.plan-presented after confirming the task is genuinely small. To create the marker: Write tool → ~/.claude/ftm-state/.plan-presented with content being the session ID."
+  }
+}
+JSON
+  exit 0
+fi
+
+# 3+ edits without a plan — stronger warning
+cat <<'JSON'
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "additionalContext": "[ftm-plan-gate WARNING] You have made 3+ file edits this session without presenting a plan. This is exactly the 'grinding without a plan' pattern that ftm-mind is supposed to prevent. STOP editing and do one of: (1) Present a numbered plan to the user and wait for approval, then write the session ID to ~/.claude/ftm-state/.plan-presented. (2) If the user explicitly said 'just do it' or this is genuinely a micro task, write the plan marker to acknowledge you've considered it. Do NOT continue editing without addressing this."
+  }
+}
+JSON
+exit 0

package/hooks/ftm-post-commit-trigger.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# PostToolUse hook: detect git commits and inject ftm-map update instructions
+
+set -euo pipefail
+
+# Read stdin into variable
+INPUT=$(cat)
+
+# Exit gracefully if stdin is empty or jq is unavailable
+if [ -z "$INPUT" ]; then
+  echo "{}"
+  exit 0
+fi
+
+if ! command -v jq &>/dev/null; then
+  echo "{}"
+  exit 0
+fi
+
+# Extract tool_name
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+
+if [ -z "$TOOL_NAME" ]; then
+  echo "{}"
+  exit 0
+fi
+
+# Check if this is a commit operation
+IS_COMMIT=0
+
+if [ "$TOOL_NAME" = "mcp__git__git_commit" ]; then
+  IS_COMMIT=1
+elif [ "$TOOL_NAME" = "Bash" ]; then
+  COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+  if [ -n "$COMMAND" ] && echo "$COMMAND" | grep -qE '^\s*git\s+commit'; then
+    IS_COMMIT=1
+  fi
+fi
+
+# Exit quickly for non-commit operations
+if [ "$IS_COMMIT" -eq 0 ]; then
+  echo "{}"
+  exit 0
+fi
+
+# Only trigger for mapped projects
+if [ ! -f ".ftm-map/map.db" ]; then
+  echo "{}"
+  exit 0
+fi
+
+# Output additionalContext to trigger ftm-map update workflow
+cat <<'EOF'
+{
+  "additionalContext": "A commit was just made. Run ftm-map incremental on changed files, then update INTENT.md and ARCHITECTURE.mmd via ftm-intent and ftm-diagram."
+}
+EOF

package/hooks/settings-template.json

@@ -0,0 +1,81 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "_comment": "FTM hooks configuration template. Merge these entries into your ~/.claude/settings.json under the 'hooks' key. install.sh can do this automatically with --setup-hooks.",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-plan-gate.sh",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__slack__slack_post_message|mcp__slack__slack_reply_to_thread|mcp__gmail__send_email",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-drafts-gate.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-discovery-reminder.sh",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-pending-sync-check.sh",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-map-autodetect.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ~/.claude/hooks/ftm-event-logger.mjs"
+          }
+        ]
+      },
+      {
+        "matcher": "Bash|mcp__git__git_commit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-post-commit-trigger.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-blackboard-enforcer.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/install.sh

@@ -4,21 +4,39 @@ set -euo pipefail
 # FTM Skills Installer
 # Creates symlinks from this repo into ~/.claude/skills/ so slash commands work.
 # Safe to re-run — idempotent. Run after cloning or adding new skills.
+#
+# Usage:
+#   ./install.sh              # Install skills, hooks, and state templates
+#   ./install.sh --setup-hooks  # Also merge hook config into settings.json
 
 REPO_DIR="$(cd "$(dirname "$0")" && pwd)"
 SKILLS_DIR="$HOME/.claude/skills"
 STATE_DIR="$HOME/.claude/ftm-state"
 CONFIG_DIR="$HOME/.claude"
+HOOKS_DIR="$HOME/.claude/hooks"
+SETTINGS_FILE="$CONFIG_DIR/settings.json"
+
+SETUP_HOOKS=false
+for arg in "$@"; do
+  case "$arg" in
+    --setup-hooks) SETUP_HOOKS=true ;;
+  esac
+done
 
-echo "Installing ftm skills from: $REPO_DIR"
+echo "Installing FTM skills from: $REPO_DIR"
 echo "Linking into: $SKILLS_DIR"
 echo ""
 
 mkdir -p "$SKILLS_DIR"
 
+# --- Skills ---
+
 # Link all ftm*.yml files
 for yml in "$REPO_DIR"/ftm*.yml; do
+  [ -f "$yml" ] || continue
   name=$(basename "$yml")
+  # Skip ftm-config.default.yml — it's a template, not a skill
+  [[ "$name" == *".default."* ]] && continue
   target="$SKILLS_DIR/$name"
   if [ -L "$target" ]; then
     rm "$target"
@@ -32,6 +50,7 @@ done
 
 # Link all ftm* directories (skills with SKILL.md)
 for dir in "$REPO_DIR"/ftm*/; do
+  [ -d "$dir" ] || continue
   name=$(basename "$dir")
   [ "$name" = "ftm-state" ] && continue  # state is handled separately
   target="$SKILLS_DIR/$name"
@@ -45,10 +64,17 @@ for dir in "$REPO_DIR"/ftm*/; do
   echo "  LINK $name/"
 done
 
-# Set up blackboard state (copy templates, don't overwrite existing data)
+SKILL_COUNT=$(ls "$REPO_DIR"/ftm*.yml 2>/dev/null | grep -v '.default.' | wc -l | tr -d ' ')
+echo ""
+echo "  $SKILL_COUNT skills linked."
+
+# --- Blackboard State ---
+
 if [ -d "$REPO_DIR/ftm-state" ]; then
+  echo ""
   mkdir -p "$STATE_DIR/blackboard/experiences"
   for f in "$REPO_DIR/ftm-state/blackboard"/*.json; do
+    [ -f "$f" ] || continue
     name=$(basename "$f")
     target="$STATE_DIR/blackboard/$name"
     if [ ! -f "$target" ]; then
@@ -63,23 +89,28 @@ if [ -d "$REPO_DIR/ftm-state" ]; then
   fi
 fi
 
-# Copy default config if none exists
+# --- Config ---
+
 if [ ! -f "$CONFIG_DIR/ftm-config.yml" ] && [ -f "$REPO_DIR/ftm-config.default.yml" ]; then
   cp "$REPO_DIR/ftm-config.default.yml" "$CONFIG_DIR/ftm-config.yml"
   echo "  INIT ftm-config.yml (from default template)"
 fi
 
-# Install hooks (copy to ~/.claude/hooks/, don't overwrite existing)
-HOOKS_DIR="$HOME/.claude/hooks"
+# --- Hooks ---
+
+echo ""
+echo "Installing hooks..."
+
 if [ -d "$REPO_DIR/hooks" ]; then
   mkdir -p "$HOOKS_DIR"
   HOOK_COUNT=0
+
+  # Install shell hooks
   for hook in "$REPO_DIR/hooks"/ftm-*.sh; do
     [ -f "$hook" ] || continue
     name=$(basename "$hook")
     target="$HOOKS_DIR/$name"
     if [ -f "$target" ]; then
-      # Overwrite — hooks should always be the latest version
       cp "$hook" "$target"
       chmod +x "$target"
       echo "  UPDATE $name"
@@ -90,13 +121,111 @@ if [ -d "$REPO_DIR/hooks" ]; then
     fi
     HOOK_COUNT=$((HOOK_COUNT + 1))
   done
-  if [ "$HOOK_COUNT" -gt 0 ]; then
-    echo ""
-    echo "  $HOOK_COUNT hooks installed to $HOOKS_DIR"
-    echo "  To activate, add them to ~/.claude/settings.json (see docs/HOOKS.md)"
+
+  # Install Node.js hooks
+  for hook in "$REPO_DIR/hooks"/ftm-*.mjs; do
+    [ -f "$hook" ] || continue
+    name=$(basename "$hook")
+    target="$HOOKS_DIR/$name"
+    if [ -f "$target" ]; then
+      cp "$hook" "$target"
+      echo "  UPDATE $name"
+    else
+      cp "$hook" "$target"
+      echo "  INSTALL $name"
+    fi
+    HOOK_COUNT=$((HOOK_COUNT + 1))
+  done
+
+  echo ""
+  echo "  $HOOK_COUNT hooks installed to $HOOKS_DIR"
+fi
+
+# --- Hook Config Merge (--setup-hooks) ---
+
+if [ "$SETUP_HOOKS" = true ]; then
+  echo ""
+  echo "Setting up hook configuration in settings.json..."
+
+  TEMPLATE="$REPO_DIR/hooks/settings-template.json"
+  if [ ! -f "$TEMPLATE" ]; then
+    echo "  ERROR: hooks/settings-template.json not found"
+    exit 1
+  fi
+
+  if ! command -v jq &>/dev/null; then
+    echo "  ERROR: jq is required for --setup-hooks. Install with: brew install jq"
+    exit 1
+  fi
+
+  # Expand ~ to $HOME in the template (jq doesn't expand shell paths)
+  EXPANDED_TEMPLATE=$(sed "s|~/.claude|$HOME/.claude|g" "$TEMPLATE")
+
+  if [ ! -f "$SETTINGS_FILE" ]; then
+    # No settings.json — create one from the template hooks section
+    echo "$EXPANDED_TEMPLATE" | jq '{hooks: .hooks}' > "$SETTINGS_FILE"
+    echo "  CREATED $SETTINGS_FILE with FTM hooks"
+  else
+    # Merge FTM hooks into existing settings.json
+    # Strategy: for each hook event type, append FTM entries that don't already exist
+    BACKUP="$SETTINGS_FILE.ftm-backup-$(date +%Y%m%d%H%M%S)"
+    cp "$SETTINGS_FILE" "$BACKUP"
+    echo "  BACKUP $BACKUP"
+
+    # Extract the hooks section from the template
+    TEMPLATE_HOOKS=$(echo "$EXPANDED_TEMPLATE" | jq '.hooks')
+
+    # Read existing settings
+    EXISTING=$(cat "$SETTINGS_FILE")
+
+    # Ensure hooks key exists
+    if echo "$EXISTING" | jq -e '.hooks' >/dev/null 2>&1; then
+      : # hooks key exists
+    else
+      EXISTING=$(echo "$EXISTING" | jq '. + {hooks: {}}')
+    fi
+
+    # Merge each hook event type
+    for EVENT in PreToolUse UserPromptSubmit PostToolUse Stop; do
+      TEMPLATE_ENTRIES=$(echo "$TEMPLATE_HOOKS" | jq --arg e "$EVENT" '.[$e] // []')
+      EXISTING_ENTRIES=$(echo "$EXISTING" | jq --arg e "$EVENT" '.hooks[$e] // []')
+
+      # Check if any FTM hooks are already present (by checking command paths)
+      FTM_COMMANDS=$(echo "$TEMPLATE_ENTRIES" | jq -r '.[].hooks[]?.command // empty' 2>/dev/null)
+      ALREADY_PRESENT=false
+
+      for cmd in $FTM_COMMANDS; do
+        cmd_basename=$(basename "$cmd")
+        if echo "$EXISTING_ENTRIES" | jq -r '.[].hooks[]?.command // empty' 2>/dev/null | grep -q "$cmd_basename"; then
+          ALREADY_PRESENT=true
+          break
+        fi
+      done
+
+      if [ "$ALREADY_PRESENT" = true ]; then
+        echo "  SKIP $EVENT hooks (already configured)"
+        continue
+      fi
+
+      # Append template entries to existing
+      MERGED=$(jq -n --argjson existing "$EXISTING_ENTRIES" --argjson template "$TEMPLATE_ENTRIES" '$existing + $template')
+      EXISTING=$(echo "$EXISTING" | jq --arg e "$EVENT" --argjson m "$MERGED" '.hooks[$e] = $m')
+      echo "  MERGE $EVENT hooks"
+    done
+
+    echo "$EXISTING" | jq '.' > "$SETTINGS_FILE"
+    echo "  UPDATED $SETTINGS_FILE"
   fi
+
+  echo ""
+  echo "  Hooks are now active. See docs/HOOKS.md for details."
+else
+  echo ""
+  echo "  To activate hooks, run: ./install.sh --setup-hooks"
+  echo "  Or manually add entries from hooks/settings-template.json to ~/.claude/settings.json"
+  echo "  See docs/HOOKS.md for details."
 fi
 
 echo ""
-echo "Done. $(ls "$REPO_DIR"/ftm*.yml 2>/dev/null | wc -l | tr -d ' ') skills linked."
+echo "Done. $SKILL_COUNT skills, $HOOK_COUNT hooks."
 echo "Try: /ftm help"