eagle-mem 3.2.0 → 3.3.0

package/README.md

@@ -159,16 +159,27 @@ The `update` command copies new files, runs any pending database migrations, and
 
 ## How it works
 
-Five hooks fire automatically at different points in Claude Code's lifecycle:
+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 |
+| **PreToolUse** | before Bash and Read calls | Rewrites noisy commands (learned rules), detects redundant reads |
 | **UserPromptSubmit** | user sends a message | FTS5 search for relevant past context |
-| **PostToolUse** | after tool calls | Records file touches, mirrors memory/plan/task writes |
+| **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 |
 | **SessionEnd** | session closes | Re-syncs tasks, marks session completed |
 
+### Token savings
+
+Eagle Mem actively reduces token consumption:
+
+- **Command rewriting** — PreToolUse rewrites noisy Bash commands (e.g., `find`, `grep`) to pipe through `head -N`, using `updatedInput` to modify the command before execution. Rules are learned by the curator from real usage, not hardcoded.
+- **Read-after-modify detection** — If you just edited or wrote a file, Eagle Mem nudges that the diff is already in context before a redundant Read.
+- **Read dedup tracking** — Files read 3+ times in a session get a soft nudge that contents are likely already in context.
+
+### Data
+
 Data lives in a single SQLite database at `~/.eagle-mem/memory.db` (WAL mode, FTS5 full-text search):
 
 | Table | What it stores |
@@ -178,6 +189,7 @@ Data lives in a single SQLite database at `~/.eagle-mem/memory.db` (WAL mode, FT
 | observations | Per-tool-use file touch records |
 | overviews | One overview per project (scan or manual) |
 | code_chunks | FTS5-indexed source file chunks |
+| command_rules | Curator-learned command output rules |
 | claude_memories | Mirror of Claude Code auto-memories |
 | claude_plans | Mirror of Claude Code plans |
 | claude_tasks | Mirror of Claude Code tasks |

package/db/020_drop_seeded_rules.sql

@@ -0,0 +1,12 @@
+-- Migration 020: Remove seeded global command rules.
+-- Self-learning pipeline (curator) now generates rules from real usage.
+-- Per-project rules created by the curator are preserved.
+--
+-- Safety: back up any existing global rules before deleting so they
+-- can be restored if a user manually created rules they want to keep.
+-- The backup table is left in place intentionally.
+
+CREATE TABLE IF NOT EXISTS _backup_020_global_rules AS
+    SELECT * FROM command_rules WHERE project = '';
+
+DELETE FROM command_rules WHERE project = '';

package/hooks/post-tool-use.sh

@@ -68,7 +68,7 @@ case "$tool_name" in
         cmd=$(echo "$cmd" | eagle_redact)
         tool_summary="Bash: $cmd"
 
-        tool_output=$(echo "$input" | jq -r '.tool_result.stdout // empty' 2>/dev/null)
+        tool_output=$(echo "$input" | jq -r '.tool_response.stdout // empty' 2>/dev/null)
         if [ -n "$tool_output" ]; then
             output_bytes=${#tool_output}
             output_lines=$(echo "$tool_output" | wc -l | tr -d ' ')
@@ -98,6 +98,25 @@ case "$tool_name" in
         ;;
 esac
 
+# ─── Track recent Edit/Write targets for Read-after-modify detection ──
+
+if [ -n "$fp" ] && [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
+    case "$tool_name" in
+        Edit|Write)
+            mod_dir="$EAGLE_MEM_DIR/mod-tracker"
+            mkdir -p "$mod_dir" 2>/dev/null
+            mod_file="$mod_dir/${session_id}"
+            echo "$fp" >> "$mod_file"
+            # Keep only last 3 entries — use per-process tmp to avoid
+            # race when parallel PostToolUse hooks fire on same session
+            if [ -f "$mod_file" ]; then
+                _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
+            ;;
+    esac
+fi
+
 # ─── Dispatch to extracted responsibilities ───────────────
 
 eagle_posttool_mirror_writes "$tool_name" "$fp" "$session_id" "$project"

package/hooks/pre-tool-use.sh

@@ -1,9 +1,11 @@
 #!/usr/bin/env bash
 # ═══════════════════════════════════════════════════════════
 # Eagle Mem — PreToolUse hook
-# Fires before every Bash tool use
+# Fires before Bash and Read tool calls
 # 1. Surfaces feature verification checklists before git push
-# 2. Applies learned command filtering rules (RTK-style adaptive)
+# 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)
 # ═══════════════════════════════════════════════════════════
 set +e
 
@@ -17,12 +19,13 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 tool_name=$(echo "$input" | jq -r '.tool_name // empty')
-[ "$tool_name" != "Bash" ] && exit 0
 
-[ ! -f "$EAGLE_MEM_DB" ] && exit 0
+case "$tool_name" in
+    Bash|Read) ;;
+    *) exit 0 ;;
+esac
 
-cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
-[ -z "$cmd" ] && exit 0
+[ ! -f "$EAGLE_MEM_DB" ] && exit 0
 
 session_id=$(echo "$input" | jq -r '.session_id // empty')
 cwd=$(echo "$input" | jq -r '.cwd // empty')
@@ -30,77 +33,120 @@ project=$(eagle_project_from_cwd "$cwd")
 [ -z "$project" ] && exit 0
 
 context=""
+updated_input=""
+
+case "$tool_name" in
+Bash)
+    cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
+    [ -z "$cmd" ] && exit 0
+
+    # ─── Feature verification on git push ─────────────────────
+
+    case "$cmd" in
+        *"git push"*|*"gh pr create"*)
+            has_features=$(eagle_count_active_features "$project")
+            if [ "${has_features:-0}" -gt 0 ]; then
+                changed_files=""
+                if [ -n "$cwd" ] && [ -d "$cwd" ]; then
+                    changed_files=$(git -C "$cwd" diff --name-only HEAD 2>/dev/null)
+                    [ -z "$changed_files" ] && changed_files=$(git -C "$cwd" diff --cached --name-only 2>/dev/null)
+                fi
 
-# ─── Feature verification on git push ─────────────────────
-
-case "$cmd" in
-    *"git push"*|*"gh pr create"*)
-        has_features=$(eagle_count_active_features "$project")
-        if [ "${has_features:-0}" -gt 0 ]; then
-            changed_files=""
-            if [ -n "$cwd" ] && [ -d "$cwd" ]; then
-                changed_files=$(git -C "$cwd" diff --name-only HEAD 2>/dev/null)
-                [ -z "$changed_files" ] && changed_files=$(git -C "$cwd" diff --cached --name-only 2>/dev/null)
-            fi
-
-            if [ -n "$changed_files" ]; then
-                seen_features=""
-                while IFS= read -r changed_file; do
-                    [ -z "$changed_file" ] && continue
-                    fname=$(basename "$changed_file")
-                    fname_esc=$(eagle_sql_escape "$fname")
-
-                    feature_hits=$(eagle_find_feature_for_push "$project" "$fname_esc")
-
-                    while IFS='|' read -r feat_name feat_smoke feat_deps feat_verified; do
-                        [ -z "$feat_name" ] && continue
-                        case "$seen_features" in *"|$feat_name|"*) continue ;; esac
-                        seen_features+="|$feat_name|"
-
-                        context+="  - $feat_name"
-                        [ -n "$feat_smoke" ] && context+=" | smoke: $feat_smoke"
-                        [ -n "$feat_deps" ] && context+=" | deps: $feat_deps"
-                        if [ -n "$feat_verified" ]; then
-                            context+=" | last verified: $feat_verified"
-                        else
-                            context+=" | never verified"
-                        fi
-                        context+=$'\n'
-                    done <<< "$feature_hits"
-                done <<< "$changed_files"
-
-                if [ -n "$context" ]; then
-                    context="Eagle Mem: This push affects the following features. After deploy, verify each works and run 'eagle-mem feature verify <name>'.
+                if [ -n "$changed_files" ]; then
+                    seen_features=""
+                    while IFS= read -r changed_file; do
+                        [ -z "$changed_file" ] && continue
+                        fname=$(basename "$changed_file")
+
+                        feature_hits=$(eagle_find_feature_for_push "$project" "$fname")
+
+                        while IFS='|' read -r feat_name feat_smoke feat_deps feat_verified; do
+                            [ -z "$feat_name" ] && continue
+                            case "$seen_features" in *"|$feat_name|"*) continue ;; esac
+                            seen_features+="|$feat_name|"
+
+                            context+="  - $feat_name"
+                            [ -n "$feat_smoke" ] && context+=" | smoke: $feat_smoke"
+                            [ -n "$feat_deps" ] && context+=" | deps: $feat_deps"
+                            if [ -n "$feat_verified" ]; then
+                                context+=" | last verified: $feat_verified"
+                            else
+                                context+=" | never verified"
+                            fi
+                            context+=$'\n'
+                        done <<< "$feature_hits"
+                    done <<< "$changed_files"
+
+                    if [ -n "$context" ]; then
+                        context="Eagle Mem: This push affects the following features. After deploy, verify each works and run 'eagle-mem feature verify <name>'.
 ${context}"
+                    fi
                 fi
             fi
-        fi
-        ;;
-esac
+            ;;
+    esac
 
-# ─── Command output filtering (learned rules) ─────────────
+    # ─── Command output filtering (learned rules) ─────────────
+
+    base_cmd=$(echo "$cmd" | awk '{print $1}' | sed 's|.*/||')
+    rule=$(eagle_get_command_rule "$project" "$base_cmd")
+
+    if [ -n "$rule" ]; then
+        IFS='|' read -r strategy max_lines reason <<< "$rule"
+        case "$strategy" in
+            truncate)
+                if [ -n "$max_lines" ] && [ "$max_lines" -gt 0 ] 2>/dev/null; then
+                    case "$cmd" in
+                        *"&&"*|*"||"*|*";"*)
+                            context+="Eagle Mem: '${base_cmd}' produces long output (${reason}). Consider: | head -${max_lines}"
+                            ;;
+                        *"| head"*|*"| tail"*|*"| wc"*|*"| grep"*|*">"*|*">>"*)
+                            ;;
+                        *)
+                            updated_input=$(jq -nc --arg cmd "${cmd} | head -${max_lines}" '{"command":$cmd}')
+                            context+="Eagle Mem: '${base_cmd}' output is typically long (${reason}). Piped through head -${max_lines}."
+                            ;;
+                    esac
+                fi
+                ;;
+            summary)
+                context+="Eagle Mem: '${base_cmd}' is typically noisy (${reason}). Consider piping through tail or checking exit code only."
+                ;;
+        esac
+    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
+
+        # ─── Read-after-modify detection ──────────────────────
+        mod_file="$EAGLE_MEM_DIR/mod-tracker/${session_id}"
+        if [ -f "$mod_file" ] && grep -qFx -- "$fp" "$mod_file" 2>/dev/null; then
+            context+="Eagle Mem: '$(basename "$fp")' was just edited/written — the diff is already in context from the tool output. "
+        fi
 
-# Extract the base command for rule matching
-base_cmd=$(echo "$cmd" | awk '{print $1}' | sed 's|.*/||')
+        # ─── Read dedup tracker (soft nudge) ──────────────────
+        tracker_dir="$EAGLE_MEM_DIR/read-tracker"
+        mkdir -p "$tracker_dir" 2>/dev/null
+        tracker_file="$tracker_dir/${session_id}"
+        echo "$fp" >> "$tracker_file"
+        read_count=$(grep -cFx -- "$fp" "$tracker_file" 2>/dev/null)
+        read_count=${read_count:-0}
+        if [ "$read_count" -ge 3 ]; then
+            context+="Eagle Mem: '$(basename "$fp")' has been read ${read_count} times this session. Its contents are likely already in context."
+        fi
+    fi
+    ;;
+esac
 
-rule=$(eagle_get_command_rule "$project" "$base_cmd")
+[ -z "$context" ] && [ -z "$updated_input" ] && exit 0
 
-if [ -n "$rule" ]; then
-    IFS='|' read -r strategy max_lines reason <<< "$rule"
-    case "$strategy" in
-        summary)
-            context+="Eagle Mem command hint: '${base_cmd}' output is typically noisy (${reason}). Consider piping through 'tail -5' or checking exit code only."
-            ;;
-        truncate)
-            if [ -n "$max_lines" ] && [ "$max_lines" -gt 0 ] 2>/dev/null; then
-                context+="Eagle Mem command hint: '${base_cmd}' produces long output (${reason}). Consider: ${cmd} | head -${max_lines}"
-            fi
-            ;;
-    esac
+if [ -n "$updated_input" ]; then
+    jq -nc --arg ctx "$context" --argjson ui "$updated_input" \
+        '{"hookSpecificOutput":{"hookEventName":"PreToolUse","updatedInput":$ui,"additionalContext":$ctx}}'
+else
+    jq -nc --arg ctx "$context" '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":$ctx}}'
 fi
 
-[ -z "$context" ] && exit 0
-
-jq -nc --arg ctx "$context" '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":$ctx}}'
-
 exit 0

package/hooks/session-start.sh

@@ -61,6 +61,10 @@ if [ "$curator_schedule" = "auto" ]; then
     fi
 fi
 
+# ─── Cleanup stale tracker files (non-blocking) ─────────────
+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 &
+
 # ─── Version check (non-blocking) ────────────────────────────
 
 update_notice=""

package/lib/db-observations.sh

@@ -52,7 +52,8 @@ eagle_get_command_rule() {
         WHERE enabled = 1
         AND (project = '$project' OR project = '')
         AND ('$cmd' LIKE pattern OR '$cmd' = pattern)
-        ORDER BY CASE WHEN project != '' THEN 0 ELSE 1 END
+        ORDER BY CASE WHEN project != '' THEN 0 ELSE 1 END,
+            LENGTH(pattern) DESC
         LIMIT 1;"
 }
 

package/lib/db-sessions.sh

@@ -15,9 +15,9 @@ eagle_upsert_session() {
     eagle_db "INSERT INTO sessions (id, project, cwd, model, source, last_activity_at)
               VALUES ('$session_id', '$project', '$cwd', '$model', '$source', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
               ON CONFLICT(id) DO UPDATE SET
-                  cwd = COALESCE(excluded.cwd, sessions.cwd),
-                  model = COALESCE(excluded.model, sessions.model),
-                  source = COALESCE(excluded.source, sessions.source),
+                  cwd = COALESCE(NULLIF(excluded.cwd, ''), sessions.cwd),
+                  model = COALESCE(NULLIF(excluded.model, ''), sessions.model),
+                  source = COALESCE(NULLIF(excluded.source, ''), sessions.source),
                   status = 'active',
                   last_activity_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
 }

package/lib/hooks.sh

@@ -11,7 +11,15 @@ eagle_patch_hook() {
     local command="$4"
     local description="${5:-}"
 
-    if jq -e ".hooks.${event}[]? | select(.hooks[]?.command == \"$command\")" "$settings" &>/dev/null; then
+    # Check both command AND matcher to avoid skipping entries with different matchers
+    # (e.g. PreToolUse with "Bash" vs "Read" matcher using the same script)
+    local match_query
+    if [ -n "$matcher" ]; then
+        match_query=".hooks.${event}[]? | select(.matcher == \"$matcher\" and (.hooks[]?.command == \"$command\"))"
+    else
+        match_query=".hooks.${event}[]? | select(.matcher == null and (.hooks[]?.command == \"$command\"))"
+    fi
+    if jq -e "$match_query" "$settings" &>/dev/null; then
         [ -n "$description" ] && eagle_ok "$description ${DIM}(already registered)${RESET}"
         return 0
     fi

package/package.json

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

package/scripts/curate.sh

@@ -222,6 +222,13 @@ If no rules needed, output: NONE"
                             eagle_log "WARN" "Curator: skipping RULE with invalid strategy '$strategy'"
                             continue
                         ;; esac
+                        # Guard: reject dangerous LLM-generated patterns that match everything
+                        # Require at least 2 literal characters (not just wildcards)
+                        _literal_chars=$(printf '%s' "$pattern" | sed 's/[%_]//g')
+                        if [ ${#_literal_chars} -lt 2 ]; then
+                            eagle_log "WARN" "Curator: skipping overly broad pattern '$pattern' (needs >=2 literal chars)"
+                            continue
+                        fi
 
                         [ "$max_lines" = "-" ] && max_lines=""
 

package/scripts/install.sh

@@ -186,7 +186,11 @@ eagle_patch_hook "$SETTINGS" "UserPromptSubmit" "" \
 
 eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash" \
     "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
-    "PreToolUse hook"
+    "PreToolUse hook (Bash)"
+
+eagle_patch_hook "$SETTINGS" "PreToolUse" "Read" \
+    "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
+    "PreToolUse hook (Read)"
 
 # ─── Install skills ────────────────────────────────────────
 

package/scripts/update.sh

@@ -76,6 +76,7 @@ if [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
     eagle_patch_hook "$SETTINGS" "SessionEnd" "" "$EAGLE_MEM_DIR/hooks/session-end.sh"
     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_ok "Hooks registered"
 fi