eagle-mem 4.0.3 → 4.1.1

package/README.md

@@ -75,8 +75,8 @@ Six hooks fire automatically at different points in Claude Code's lifecycle:
 
 | Hook | Fires when | What it does |
 |------|-----------|--------------|
-| **SessionStart** | startup, resume, clear, compact | Injects overview, summaries, memories, tasks. Auto-provisions new projects (scan, index). |
-| **PreToolUse** | before Bash and Read calls | Rewrites noisy commands (learned rules), detects redundant reads |
+| **SessionStart** | startup, resume, clear, compact | Injects overview, summaries, memories, tasks, core files, working set. Auto-provisions new projects (scan, index). |
+| **PreToolUse** | before Bash, Read, Edit, and Write calls | Rewrites noisy commands (learned rules), detects redundant reads, nudges co-edit partners |
 | **UserPromptSubmit** | user sends a message | FTS5 search for relevant past context |
 | **PostToolUse** | after tool calls | Records file touches, mirrors memory/plan/task writes, tracks modifications |
 | **Stop** | Claude's turn ends | Extracts `<eagle-summary>`, strips `<private>` tags |
@@ -89,7 +89,7 @@ These run automatically via SessionStart — no commands needed:
 - **Auto-scan** — new project with no overview triggers a codebase scan
 - **Auto-index** — new or stale project triggers FTS5 source indexing
 - **Auto-prune** — observations over 10K rows trigger cleanup
-- **Auto-curate** — the self-learning curator analyzes observation data and generates project-specific command rules (requires LLM provider)
+- **Auto-curate** — the self-learning curator analyzes observation data and generates command rules, co-edit patterns, and hot file detection (partially requires LLM provider)
 
 ### Token savings
 
@@ -99,6 +99,10 @@ Eagle Mem actively reduces token consumption:
 - **Command rewriting** — PreToolUse rewrites noisy Bash commands to pipe through `head -N` via `updatedInput`. Rules are learned by the curator from real usage, not hardcoded.
 - **Read-after-modify detection** — detects when you read a file that was just edited or written, nudges that the diff is already in context
 - **Read dedup tracking** — files read 3+ times in a session get a soft nudge
+- **Co-edit nudges** — learned from observation data: when you edit file X, PreToolUse reminds you that you usually also touch file Y
+- **Hot file awareness** — curator identifies files read in 50%+ of sessions; SessionStart flags them as "likely in context" to reduce re-reads
+- **Working set recovery** — on compact, SessionStart injects the files you were actively editing so you resume without re-reading everything
+- **Stuck loop detection** — if the same file is edited 5+ times in one session, PreToolUse nudges to reconsider the approach
 
 ### Data
 
@@ -112,6 +116,7 @@ Single SQLite database at `~/.eagle-mem/memory.db` (WAL mode, FTS5 full-text sea
 | overviews | One overview per project (auto-scan or manual) |
 | code_chunks | FTS5-indexed source file chunks |
 | command_rules | Curator-learned command output rules |
+| file_hints | Curator-learned file access patterns (co-edit pairs) |
 | claude_memories | Mirror of Claude Code auto-memories |
 | claude_plans | Mirror of Claude Code plans |
 | claude_tasks | Mirror of Claude Code tasks |

package/db/021_file_hints.sql

@@ -0,0 +1,15 @@
+-- Migration 021: File hints — learned file access patterns from curator
+-- Stores co-edit patterns, hot files, and other learned behaviors.
+
+CREATE TABLE IF NOT EXISTS file_hints (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project TEXT NOT NULL,
+    hint_type TEXT NOT NULL CHECK (hint_type IN ('co_edit', 'hot_file', 'read_threshold', 'session_profile')),
+    file_path TEXT NOT NULL DEFAULT '',
+    hint_value TEXT NOT NULL,
+    created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE(project, hint_type, file_path)
+);
+
+CREATE INDEX IF NOT EXISTS idx_file_hints_lookup ON file_hints(project, hint_type, file_path);

package/hooks/post-tool-use.sh

@@ -113,6 +113,11 @@ if [ -n "$fp" ] && [ -n "$session_id" ] && eagle_validate_session_id "$session_i
                 _mod_tmp=$(mktemp "${mod_file}.XXXXXX" 2>/dev/null) || _mod_tmp="${mod_file}.$$"
                 tail -3 "$mod_file" > "$_mod_tmp" && mv "$_mod_tmp" "$mod_file" || rm -f "$_mod_tmp"
             fi
+
+            # Full edit history for stuck loop detection (not truncated)
+            edit_dir="$EAGLE_MEM_DIR/edit-tracker"
+            mkdir -p "$edit_dir" 2>/dev/null
+            echo "$fp" >> "$edit_dir/${session_id}"
             ;;
     esac
 fi

package/hooks/pre-tool-use.sh

@@ -1,11 +1,13 @@
 #!/usr/bin/env bash
 # ═══════════════════════════════════════════════════════════
 # Eagle Mem — PreToolUse hook
-# Fires before Bash and Read tool calls
+# Fires before Bash, Read, Edit, Write tool calls
 # 1. Surfaces feature verification checklists before git push
 # 2. Truncates noisy commands via updatedInput (curator-learned rules)
 # 3. Detects Read-after-Edit/Write (content already in context)
 # 4. Nudges on repeated file reads (dedup tracker)
+# 5. Co-edit nudge on Edit/Write (curator-learned pairs)
+# 6. Stuck loop detection (repeated edits to same file)
 # ═══════════════════════════════════════════════════════════
 set +e
 
@@ -21,7 +23,7 @@ input=$(eagle_read_stdin)
 tool_name=$(echo "$input" | jq -r '.tool_name // empty')
 
 case "$tool_name" in
-    Bash|Read) ;;
+    Bash|Read|Edit|Write) ;;
     *) exit 0 ;;
 esac
 
@@ -116,6 +118,42 @@ ${context}"
     fi
     ;;
 
+Edit|Write)
+    fp=$(echo "$input" | jq -r '.tool_input.file_path // empty')
+    if [ -n "$fp" ]; then
+        # ─── Stuck loop detection ─────────────────────────
+        if [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
+            edit_tracker="$EAGLE_MEM_DIR/edit-tracker/${session_id}"
+            if [ -f "$edit_tracker" ]; then
+                edit_count=$(grep -cFx -- "$fp" "$edit_tracker" 2>/dev/null)
+                edit_count=${edit_count:-0}
+                if [ "$edit_count" -ge 8 ]; then
+                    context+="Eagle Mem: '$(basename "$fp")' has been edited ${edit_count} times this session. You may be stuck — consider stepping back to rethink your approach before making more changes. "
+                elif [ "$edit_count" -ge 5 ]; then
+                    context+="Eagle Mem: '$(basename "$fp")' has been edited ${edit_count} times this session. If the changes aren't converging, consider a different approach. "
+                fi
+            fi
+        fi
+
+        # ─── Co-edit nudge (skip SQLite call if no co-edit hints exist) ──
+        _proj_hash=$(printf '%s' "$project" | shasum | cut -c1-8)
+        co_edit_marker="$EAGLE_MEM_DIR/.co-edit-active.${_proj_hash}"
+        co_edits=""
+        if [ -f "$co_edit_marker" ]; then
+            co_edits=$(eagle_get_co_edits "$project" "$fp")
+        fi
+        if [ -n "$co_edits" ]; then
+            partners=""
+            IFS=',' read -ra co_arr <<< "$co_edits"
+            for co_file in "${co_arr[@]}"; do
+                [ -n "$co_file" ] && partners+="$(basename "$co_file"), "
+            done
+            partners=${partners%, }
+            context+="Eagle Mem: When you change '$(basename "$fp")' you usually also touch: $partners"
+        fi
+    fi
+    ;;
+
 Read)
     fp=$(echo "$input" | jq -r '.tool_input.file_path // empty')
     if [ -n "$fp" ] && [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then

package/hooks/session-start.sh

@@ -45,6 +45,7 @@ eagle_sessionstart_auto_curate "$project" "$SCRIPTS_DIR"
 
 find "$EAGLE_MEM_DIR/read-tracker" -type f -mtime +1 -delete 2>/dev/null &
 find "$EAGLE_MEM_DIR/mod-tracker" -type f -mtime +1 -delete 2>/dev/null &
+find "$EAGLE_MEM_DIR/edit-tracker" -type f -mtime +1 -delete 2>/dev/null &
 
 # ─── Version check (non-blocking) ────────────────────────
 
@@ -264,6 +265,36 @@ if [ -n "$synced_tasks" ]; then
     done <<< "$synced_tasks"
 fi
 
+# ─── Core files (hot file hints from curator) ───────────
+
+hot_files=$(eagle_get_hot_files "$project")
+if [ -n "$hot_files" ]; then
+    context+="
+=== Core Files (frequently read — re-read sparingly if unchanged) ===
+"
+    IFS=',' read -ra hf_arr <<< "$hot_files"
+    for hf in "${hf_arr[@]}"; do
+        [ -n "$hf" ] && context+="  - $(basename "$hf")
+"
+    done
+fi
+
+# ─── Working set (on compact — what you were editing) ────
+
+if [ "$source_type" = "compact" ] || [ "$source_type" = "clear" ]; then
+    working_set=$(eagle_get_working_set "$session_id")
+    if [ -n "$working_set" ]; then
+        context+="
+=== Working Set (files you were modifying before compact) ===
+"
+        while IFS='|' read -r ws_path ws_edits; do
+            [ -z "$ws_path" ] && continue
+            context+="  - $(basename "$ws_path") (${ws_edits} edits)
+"
+        done <<< "$working_set"
+    fi
+fi
+
 # ─── Instructions (compressed) ───────────────────────────
 
 if [ "$source_type" = "compact" ] || [ "$source_type" = "clear" ]; then

package/hooks/stop.sh

@@ -38,15 +38,6 @@ eagle_log "INFO" "Stop: session=$session_id project=$project transcript=$transcr
 # Ensure session exists (may not if SessionStart didn't fire)
 eagle_upsert_session "$session_id" "$project" "$cwd" "" ""
 
-# ─── Guard: skip if summary already exists for this session ──
-# Stop fires every assistant turn. Only process once per session.
-
-existing_count=$(eagle_count_session_summaries "$session_id")
-if [ "${existing_count:-0}" -gt 0 ]; then
-    eagle_log "INFO" "Stop: summary already exists for session=$session_id — skipping"
-    exit 0
-fi
-
 [ -z "$transcript_path" ] || [ ! -f "$transcript_path" ] && exit 0
 
 # ─── Primary: heuristic extraction from transcript ───────────
@@ -67,7 +58,7 @@ fi
 
 investigated=""
 learned=""
-completed="(auto-captured)"
+completed=""
 next_steps=""
 notes=""
 decisions=""
@@ -134,8 +125,16 @@ if [ -n "$summary_block" ]; then
 fi
 
 # ─── LLM enrichment: fill in decisions/gotchas/key_files ─────
+# Check both local vars (from eagle-summary block) AND existing DB enrichment.
+# Skip LLM call if either source already has enrichment data.
 
+existing_enrichment=""
 if [ -z "$decisions" ] && [ -z "$gotchas" ] && [ -z "$key_files" ]; then
+    s_esc=$(eagle_sql_escape "$session_id")
+    existing_enrichment=$(eagle_db "SELECT decisions||gotchas||key_files FROM summaries WHERE session_id='$s_esc';")
+fi
+
+if [ -z "$decisions" ] && [ -z "$gotchas" ] && [ -z "$key_files" ] && [ -z "$existing_enrichment" ]; then
     provider=$(eagle_config_get "provider" "type" "none" 2>/dev/null)
     if [ "$provider" != "none" ] && [ -n "$text_content" ]; then
         excerpt=$(echo "$text_content" | tail -c 2000)

package/lib/db-core.sh

@@ -7,7 +7,6 @@ _EAGLE_DB_CORE_LOADED=1
 
 EAGLE_DB_SETUP=".headers off
 .output /dev/null
-PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
 PRAGMA busy_timeout=5000;
 PRAGMA foreign_keys=ON;

package/lib/db-hints.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — File hint helpers (learned patterns from curator)
+# ═══════════════════════════════════════════════════════════
+[ -n "${_EAGLE_DB_HINTS_LOADED:-}" ] && return 0
+_EAGLE_DB_HINTS_LOADED=1
+
+eagle_upsert_file_hint() {
+    local project; project=$(eagle_sql_escape "$1")
+    local hint_type; hint_type=$(eagle_sql_escape "$2")
+    local file_path; file_path=$(eagle_sql_escape "$3")
+    local hint_value; hint_value=$(eagle_sql_escape "$4")
+
+    eagle_db "INSERT INTO file_hints (project, hint_type, file_path, hint_value)
+        VALUES ('$project', '$hint_type', '$file_path', '$hint_value')
+        ON CONFLICT(project, hint_type, file_path) DO UPDATE SET
+            hint_value = excluded.hint_value,
+            updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
+}
+
+eagle_get_co_edits() {
+    local project; project=$(eagle_sql_escape "$1")
+    local file_path; file_path=$(eagle_sql_escape "$2")
+
+    eagle_db "SELECT hint_value FROM file_hints
+        WHERE project = '$project'
+        AND hint_type = 'co_edit'
+        AND file_path = '$file_path'
+        LIMIT 1;"
+}
+
+eagle_get_hot_files() {
+    local project; project=$(eagle_sql_escape "$1")
+
+    eagle_db "SELECT hint_value FROM file_hints
+        WHERE project = '$project'
+        AND hint_type = 'hot_file'
+        AND file_path = ''
+        LIMIT 1;"
+}
+
+eagle_get_working_set() {
+    local session_id; session_id=$(eagle_sql_escape "$1")
+
+    eagle_db "SELECT
+        CASE tool_name
+            WHEN 'Edit' THEN SUBSTR(tool_input_summary, 6)
+            WHEN 'Write' THEN SUBSTR(tool_input_summary, 7)
+        END as file_path,
+        COUNT(*) as edits
+    FROM observations
+    WHERE session_id = '$session_id'
+    AND tool_name IN ('Edit', 'Write')
+    AND tool_input_summary IS NOT NULL
+    GROUP BY file_path
+    ORDER BY MAX(created_at) DESC
+    LIMIT 10;"
+}
+
+eagle_delete_file_hints() {
+    local project; project=$(eagle_sql_escape "$1")
+    local hint_type; hint_type=$(eagle_sql_escape "$2")
+
+    eagle_db "DELETE FROM file_hints
+        WHERE project = '$project'
+        AND hint_type = '$hint_type';"
+}

package/lib/db.sh

@@ -14,4 +14,5 @@ _eagle_db_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 . "$_eagle_db_dir/db-summaries.sh"
 . "$_eagle_db_dir/db-mirrors.sh"
 . "$_eagle_db_dir/db-features.sh"
+. "$_eagle_db_dir/db-hints.sh"
 . "$_eagle_db_dir/db-backfill.sh"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "4.0.3",
+  "version": "4.1.1",
   "description": "Persistent memory for Claude Code — SQLite + FTS5, no daemon, no bloat",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/curate.sh

@@ -6,6 +6,8 @@
 # 2. Superseded decision detection
 # 3. Command compression rules
 # 4. Feature auto-discovery
+# 5. Co-edit pattern detection
+# 6. Hot file detection
 # ═══════════════════════════════════════════════════════════
 set -euo pipefail
 
@@ -348,7 +350,167 @@ else
     eagle_dim "  Not enough session data for feature discovery"
 fi
 
-# ─── 5. Session compression (--full only) ─────────────────
+# ─── 5. Co-edit pattern detection (pure SQL) ─────────────
+
+eagle_info "Analyzing co-edit patterns..."
+
+# Need 3+ sessions with edits — with fewer, every pair trivially co-occurs
+edit_sessions=$(eagle_db "SELECT COUNT(DISTINCT session_id) FROM observations
+    WHERE project = '$p_esc' AND tool_name IN ('Edit', 'Write');")
+
+co_edit_data=""
+if [ "${edit_sessions:-0}" -ge 3 ]; then
+    co_edit_data=$(eagle_db "WITH edits AS (
+        SELECT session_id,
+            CASE tool_name
+                WHEN 'Edit' THEN SUBSTR(tool_input_summary, 6)
+                WHEN 'Write' THEN SUBSTR(tool_input_summary, 7)
+            END as file_path
+        FROM observations
+        WHERE project = '$p_esc'
+        AND tool_name IN ('Edit', 'Write')
+        AND tool_input_summary IS NOT NULL
+    ),
+    file_stats AS (
+        SELECT file_path, COUNT(DISTINCT session_id) as edit_sessions
+        FROM edits GROUP BY file_path
+    ),
+    -- Filter files edited in >85% of all edit sessions (like .env — changes with everything)
+    noisy_files AS (
+        SELECT file_path FROM file_stats
+        WHERE CAST(edit_sessions AS REAL) / $edit_sessions > 0.85
+    )
+    SELECT e1.file_path as f1, e2.file_path as f2,
+        COUNT(DISTINCT e1.session_id) as co_sessions
+    FROM edits e1
+    JOIN edits e2 ON e1.session_id = e2.session_id AND e1.file_path < e2.file_path
+    WHERE e1.file_path NOT IN (SELECT file_path FROM noisy_files)
+    AND e2.file_path NOT IN (SELECT file_path FROM noisy_files)
+    GROUP BY f1, f2
+    HAVING co_sessions >= 2
+    ORDER BY co_sessions DESC
+    LIMIT 30;")
+fi
+
+if [ -n "$co_edit_data" ]; then
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "  Co-edit pairs found:"
+    fi
+
+    co_edit_count=0
+    declare -A co_map
+
+    while IFS='|' read -r f1 f2 co_sessions; do
+        [ -z "$f1" ] || [ -z "$f2" ] && continue
+
+        # Build comma-separated partner list per file (both directions)
+        if [ -n "${co_map[$f1]+x}" ]; then
+            co_map[$f1]="${co_map[$f1]},$f2"
+        else
+            co_map[$f1]="$f2"
+        fi
+        if [ -n "${co_map[$f2]+x}" ]; then
+            co_map[$f2]="${co_map[$f2]},$f1"
+        else
+            co_map[$f2]="$f1"
+        fi
+        co_edit_count=$((co_edit_count + 1))
+    done <<< "$co_edit_data"
+
+    if [ "$DRY_RUN" -eq 1 ]; then
+        for f in "${!co_map[@]}"; do
+            eagle_info "    $(basename "$f") → ${co_map[$f]}"
+        done
+    else
+        {
+            echo "BEGIN;"
+            echo "DELETE FROM file_hints WHERE project = '$(eagle_sql_escape "$project")' AND hint_type = 'co_edit';"
+            for f in "${!co_map[@]}"; do
+                local_f=$(eagle_sql_escape "$f")
+                local_v=$(eagle_sql_escape "${co_map[$f]}")
+                echo "INSERT INTO file_hints (project, hint_type, file_path, hint_value) VALUES ('$(eagle_sql_escape "$project")', 'co_edit', '$local_f', '$local_v') ON CONFLICT(project, hint_type, file_path) DO UPDATE SET hint_value = excluded.hint_value, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
+            done
+            echo "COMMIT;"
+        } | eagle_db_pipe
+        _proj_hash=$(printf '%s' "$project" | shasum | cut -c1-8)
+        touch "$EAGLE_MEM_DIR/.co-edit-active.${_proj_hash}"
+        eagle_log "INFO" "Curator: stored ${#co_map[@]} co-edit hints from $co_edit_count pairs"
+    fi
+    eagle_ok "$co_edit_count co-edit pairs found (${#co_map[@]} files)"
+else
+    if [ "$DRY_RUN" -eq 0 ]; then
+        eagle_delete_file_hints "$project" "co_edit"
+        _proj_hash=$(printf '%s' "$project" | shasum | cut -c1-8)
+        rm -f "$EAGLE_MEM_DIR/.co-edit-active.${_proj_hash}"
+    fi
+    eagle_dim "  Not enough edit data for co-edit detection (need 3+ sessions, have ${edit_sessions:-0})"
+fi
+
+# ─── 6. Hot file detection (pure SQL) ────────────────────
+
+eagle_info "Detecting hot files..."
+
+total_sessions=$(eagle_db "SELECT COUNT(DISTINCT session_id) FROM observations
+    WHERE project = '$p_esc' AND tool_name = 'Read';")
+
+hot_file_data=""
+if [ "${total_sessions:-0}" -ge 3 ]; then
+    hot_file_data=$(eagle_db "WITH read_stats AS (
+        SELECT
+            SUBSTR(tool_input_summary, 6) as file_path,
+            COUNT(*) as total_reads,
+            COUNT(DISTINCT session_id) as sessions_read
+        FROM observations
+        WHERE project = '$p_esc'
+        AND tool_name = 'Read'
+        AND tool_input_summary IS NOT NULL
+        GROUP BY file_path
+    )
+    SELECT file_path, total_reads, sessions_read,
+        CAST(total_reads * 1.0 / sessions_read AS INTEGER) as reads_per_session
+    FROM read_stats
+    WHERE (CAST(sessions_read AS REAL) / $total_sessions > 0.5
+           OR total_reads * 1.0 / sessions_read >= 10)
+    AND total_reads >= 5
+    ORDER BY reads_per_session DESC
+    LIMIT 15;")
+fi
+
+if [ -n "$hot_file_data" ]; then
+    hot_files=""
+    hot_count=0
+
+    while IFS='|' read -r hf_path hf_reads hf_sessions hf_rps; do
+        [ -z "$hf_path" ] && continue
+        if [ -n "$hot_files" ]; then
+            hot_files+=","
+        fi
+        hot_files+="$hf_path"
+        hot_count=$((hot_count + 1))
+
+        if [ "$DRY_RUN" -eq 1 ]; then
+            eagle_info "    $(basename "$hf_path") — ${hf_rps} reads/session, ${hf_sessions}/${total_sessions} sessions"
+        fi
+    done <<< "$hot_file_data"
+
+    if [ "$DRY_RUN" -eq 0 ] && [ -n "$hot_files" ]; then
+        {
+            echo "BEGIN;"
+            echo "DELETE FROM file_hints WHERE project = '$(eagle_sql_escape "$project")' AND hint_type = 'hot_file';"
+            echo "INSERT INTO file_hints (project, hint_type, file_path, hint_value) VALUES ('$(eagle_sql_escape "$project")', 'hot_file', '', '$(eagle_sql_escape "$hot_files")') ON CONFLICT(project, hint_type, file_path) DO UPDATE SET hint_value = excluded.hint_value, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
+            echo "COMMIT;"
+        } | eagle_db_pipe
+        eagle_log "INFO" "Curator: stored $hot_count hot files"
+    fi
+    eagle_ok "$hot_count hot files detected"
+else
+    if [ "$DRY_RUN" -eq 0 ]; then
+        eagle_delete_file_hints "$project" "hot_file"
+    fi
+    eagle_dim "  Not enough session data for hot file detection (need 3+ sessions, have ${total_sessions:-0})"
+fi
+
+# ─── 7. Session compression (--full only) ─────────────────
 
 if [ "$FULL" -eq 1 ]; then
     eagle_info "Compressing old sessions..."

package/scripts/install.sh

@@ -192,6 +192,14 @@ eagle_patch_hook "$SETTINGS" "PreToolUse" "Read" \
     "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
     "PreToolUse hook (Read)"
 
+eagle_patch_hook "$SETTINGS" "PreToolUse" "Edit" \
+    "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
+    "PreToolUse hook (Edit)"
+
+eagle_patch_hook "$SETTINGS" "PreToolUse" "Write" \
+    "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
+    "PreToolUse hook (Write)"
+
 # ─── Install skills ────────────────────────────────────────
 
 if [ -d "$PACKAGE_DIR/skills" ]; then

package/scripts/update.sh

@@ -77,6 +77,8 @@ if [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
     eagle_patch_hook "$SETTINGS" "UserPromptSubmit" "" "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh"
     eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
     eagle_patch_hook "$SETTINGS" "PreToolUse" "Read" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
+    eagle_patch_hook "$SETTINGS" "PreToolUse" "Edit" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
+    eagle_patch_hook "$SETTINGS" "PreToolUse" "Write" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
 
     eagle_ok "Hooks registered"
 fi