eagle-mem 1.4.7 → 1.5.1

package/README.md

@@ -1,19 +1,6 @@
 ```
-        .~~~~-.
-       /    ,__`)
-      |      \o/|'-.
-      |         /  ,\
-      |        ('--./
-      /         \
-     /  ,  ,  ,  \
-     `--'--'--'--'
-
-███████╗░█████╗░░██████╗░██╗░░░░░███████╗  ███╗░░░███╗███████╗███╗░░░███╗
-██╔════╝██╔══██╗██╔════╝░██║░░░░░██╔════╝  ████╗░████║██╔════╝████╗░████║
-█████╗░░███████║██║░░██╗░██║░░░░░█████╗░░  ██╔████╔██║█████╗░░██╔████╔██║
-██╔══╝░░██╔══██║██║░░╚██╗██║░░░░░██╔══╝░░  ██║╚██╔╝██║██╔══╝░░██║╚██╔╝██║
-███████╗██║░░██║╚██████╔╝███████╗███████╗  ██║░╚═╝░██║███████╗██║░╚═╝░██║
-╚══════╝╚═╝░░╚═╝░╚═════╝░╚══════╝╚══════╝  ╚═╝░░░░░╚═╝╚══════╝╚═╝░░░░░╚═╝
+█▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
+██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █
 ```
 
 # Eagle Mem
@@ -32,14 +19,8 @@ eagle-mem install
 The installer checks prerequisites and offers to install missing ones:
 
 ```
-        .~~~~-.
-       /    ,__`)
-      |      \o/|'-.
-      |         /  ,\
-      |        ('--./
-      /         \
-     /  ,  ,  ,  \
-     `--'--'--'--'
+  █▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
+  ██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █
 
   Eagle Mem  Install
   ─────────────────────────────────────
@@ -64,14 +45,12 @@ The installer checks prerequisites and offers to install missing ones:
 Start a new Claude Code session — Eagle Mem activates automatically and shows:
 
 ```
-        .~~~~-.
-       /    ,__`)
-      |      \o/|'-.       Eagle Mem loaded
-      |         /  ,\       Project: my-app
-      |        ('--./       Sessions: 5 recent | Memories: 3 | Tasks: 2 pending
-      /         \           Last: Added auth middleware with JWT validation
-     /  ,  ,  ,  \
-     `--'--'--'--'
+█▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
+██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █
+
+Project: my-app
+Sessions: 5 recent | Memories: 3 | Tasks: 2 pending
+Last: Added auth middleware with JWT validation
 ```
 
 ## Commands
@@ -213,11 +192,15 @@ Single shared SQLite database at `~/.eagle-mem/memory.db` with a `project` colum
 
 ## Skills
 
-Eagle Mem ships with three skills for use inside Claude Code sessions:
+Eagle Mem ships with seven skills for use inside Claude Code sessions:
 
 - **eagle-mem-search** — 3-layer search: compact FTS5 search, timeline view, full observations
 - **eagle-mem-tasks** — TaskAware Compact Loop: create, view, complete, and manage subtasks
 - **eagle-mem-overview** — Generate and update a persistent project overview
+- **eagle-mem-index** — Index source files for FTS5 code-level search
+- **eagle-mem-scan** — Scan and analyze a project to generate an overview
+- **eagle-mem-memories** — Browse and search Claude Code memories, plans, and tasks
+- **eagle-mem-prune** — Clean up old observations and orphaned chunks
 
 ## Architecture
 
@@ -236,19 +219,24 @@ Package (npm)                   Runtime (~/.eagle-mem/)
 │   ├── overview.sh             │   └── db.sh
 │   ├── memories.sh             └── db/
 │   ├── prune.sh                    ├── migrate.sh
-│   └── help.sh                    ├── schema.sql
-├── hooks/          Source          ├── 002_overviews.sql
-├── lib/            Source          ├── 003_code_chunks.sql
-│   ├── common.sh                  ├── 004_observation_indexes.sql
-│   └── db.sh                      ├── 005_claude_memories.sql
-├── db/             Source          ├── 006_claude_plans.sql
-│   ├── migrate.sh                 └── 007_claude_tasks.sql
+│   ├── statusline-em.sh            ├── schema.sql
+│   └── help.sh                    ├── 002_overviews.sql
+├── hooks/          Source          ├── 003_code_chunks.sql
+├── lib/            Source          ├── 004_observation_indexes.sql
+│   ├── common.sh                  ├── 005_claude_memories.sql
+│   └── db.sh                      ├── 006_claude_plans.sql
+├── db/             Source          └── 007_claude_tasks.sql
+│   ├── migrate.sh
 │   ├── schema.sql
 │   └── migrations
 └── skills/         Symlinked → ~/.claude/skills/
     ├── eagle-mem-search/
     ├── eagle-mem-tasks/
-    └── eagle-mem-overview/
+    ├── eagle-mem-overview/
+    ├── eagle-mem-index/
+    ├── eagle-mem-scan/
+    ├── eagle-mem-memories/
+    └── eagle-mem-prune/
 ```
 
 ## Uninstall

package/db/008_summary_upsert.sql

@@ -0,0 +1,57 @@
+-- Migration 008: Enforce one summary per session
+-- Removes duplicate summaries (keeps the latest) and adds UNIQUE constraint.
+-- Recreates FTS triggers since DROP TABLE removes them.
+
+-- Delete duplicates, keeping only the row with the highest id per session
+DELETE FROM summaries WHERE id NOT IN (
+    SELECT MAX(id) FROM summaries GROUP BY session_id
+);
+
+-- Rebuild FTS index to match cleaned data
+INSERT INTO summaries_fts(summaries_fts) VALUES('rebuild');
+
+-- Drop old triggers (they'll be gone after table rebuild anyway)
+DROP TRIGGER IF EXISTS summaries_ai;
+DROP TRIGGER IF EXISTS summaries_ad;
+DROP TRIGGER IF EXISTS summaries_au;
+
+-- Recreate table with UNIQUE(session_id)
+CREATE TABLE summaries_new (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id      TEXT NOT NULL UNIQUE REFERENCES sessions(id),
+    project         TEXT NOT NULL,
+    request         TEXT,
+    investigated    TEXT,
+    learned         TEXT,
+    completed       TEXT,
+    next_steps      TEXT,
+    files_read      TEXT DEFAULT '[]',
+    files_modified  TEXT DEFAULT '[]',
+    notes           TEXT,
+    created_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+INSERT INTO summaries_new SELECT * FROM summaries;
+DROP TABLE summaries;
+ALTER TABLE summaries_new RENAME TO summaries;
+
+CREATE INDEX IF NOT EXISTS idx_summaries_session ON summaries(session_id);
+CREATE INDEX IF NOT EXISTS idx_summaries_project ON summaries(project);
+
+-- Recreate FTS content-sync triggers
+CREATE TRIGGER summaries_ai AFTER INSERT ON summaries BEGIN
+    INSERT INTO summaries_fts(rowid, request, investigated, learned, completed, next_steps, notes)
+    VALUES (new.id, new.request, new.investigated, new.learned, new.completed, new.next_steps, new.notes);
+END;
+
+CREATE TRIGGER summaries_ad AFTER DELETE ON summaries BEGIN
+    INSERT INTO summaries_fts(summaries_fts, rowid, request, investigated, learned, completed, next_steps, notes)
+    VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes);
+END;
+
+CREATE TRIGGER summaries_au AFTER UPDATE ON summaries BEGIN
+    INSERT INTO summaries_fts(summaries_fts, rowid, request, investigated, learned, completed, next_steps, notes)
+    VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes);
+    INSERT INTO summaries_fts(rowid, request, investigated, learned, completed, next_steps, notes)
+    VALUES (new.id, new.request, new.investigated, new.learned, new.completed, new.next_steps, new.notes);
+END;

package/db/migrate.sh

@@ -19,8 +19,13 @@ run_migration() {
     already_applied=$(sqlite3 "$DB" "SELECT COUNT(*) FROM _migrations WHERE name = '$name';" 2>/dev/null || echo "0")
 
     if [ "$already_applied" = "0" ]; then
-        sqlite3 "$DB" < "$file"
-        sqlite3 "$DB" "INSERT INTO _migrations (name) VALUES ('$name');"
+        # Strip PRAGMAs from migration body (they can't run inside transactions
+        # and are already set on every connection via lib/db.sh EAGLE_DB_SETUP)
+        local body
+        body=$(grep -v -E '^[[:space:]]*PRAGMA ' "$file")
+
+        # Set connection PRAGMAs, then run migration body + tracking insert atomically
+        { echo "PRAGMA trusted_schema=ON;"; echo "PRAGMA foreign_keys=ON;"; echo "PRAGMA busy_timeout=5000;"; echo "BEGIN;"; echo "$body"; echo "INSERT INTO _migrations (name) VALUES ('$name');"; echo "COMMIT;"; } | sqlite3 "$DB"
         echo "  applied: $name"
     fi
 }
@@ -56,4 +61,7 @@ run_migration "006_claude_plans" "$SCRIPT_DIR/006_claude_plans.sql"
 # ─── Migration 007: Claude Code task mirror ──────────────
 run_migration "007_claude_tasks" "$SCRIPT_DIR/007_claude_tasks.sql"
 
+# ─── Migration 008: Summary UPSERT (unique session_id) ───
+run_migration "008_summary_upsert" "$SCRIPT_DIR/008_summary_upsert.sql"
+
 echo "  Eagle Mem database ready: $DB"

package/hooks/post-tool-use.sh

@@ -60,7 +60,16 @@ case "$tool_name" in
             -e 's/(password[= :])[^ ]*/\1[REDACTED]/gi' \
             -e 's/(secret[= :])[^ ]*/\1[REDACTED]/gi' \
             -e 's/(token[= :])[^ ]*/\1[REDACTED]/gi' \
-            -e 's/(Authorization: )[^ ]*/\1[REDACTED]/gi')
+            -e 's/(Authorization: )[^ ]*/\1[REDACTED]/gi' \
+            -e 's/sk_live_[A-Za-z0-9]+/[REDACTED]/g' \
+            -e 's/sk_test_[A-Za-z0-9]+/[REDACTED]/g' \
+            -e 's/AKIA[A-Z0-9]{16}/[REDACTED]/g' \
+            -e 's/ghp_[A-Za-z0-9]{36}/[REDACTED]/g' \
+            -e 's/gho_[A-Za-z0-9]{36}/[REDACTED]/g' \
+            -e 's/sk-ant-[A-Za-z0-9_-]+/[REDACTED]/g' \
+            -e 's/sk-[A-Za-z0-9]{20,}/[REDACTED]/g' \
+            -e 's/(ANTHROPIC_API_KEY[= :])[^ ]*/\1[REDACTED]/g' \
+            -e 's/(OPENAI_API_KEY[= :])[^ ]*/\1[REDACTED]/g')
         tool_summary="Bash: $cmd"
         ;;
     TaskCreate|TaskUpdate)
@@ -95,15 +104,17 @@ esac
 # Intercept TaskCreate/TaskUpdate and capture the resulting JSON files
 case "$tool_name" in
     TaskCreate|TaskUpdate)
-        task_dir="$HOME/.claude/tasks/$session_id"
-        if [ -d "$task_dir" ]; then
-            task_id=$(echo "$input" | jq -r '.tool_input.id // empty')
-            if [ -z "$task_id" ]; then
-                newest=$(ls -t "$task_dir"/*.json 2>/dev/null | head -1)
-                [ -n "$newest" ] && [ -f "$newest" ] && eagle_capture_claude_task "$newest" "$session_id" "$project"
-            else
-                task_json="$task_dir/$task_id.json"
-                [ -f "$task_json" ] && eagle_capture_claude_task "$task_json" "$session_id" "$project"
+        if eagle_validate_session_id "$session_id"; then
+            task_dir="$HOME/.claude/tasks/$session_id"
+            if [ -d "$task_dir" ]; then
+                task_id=$(echo "$input" | jq -r '.tool_input.id // empty')
+                if [ -z "$task_id" ]; then
+                    newest=$(ls -t "$task_dir"/*.json 2>/dev/null | head -1)
+                    [ -n "$newest" ] && [ -f "$newest" ] && eagle_capture_claude_task "$newest" "$session_id" "$project"
+                elif eagle_validate_session_id "$task_id"; then
+                    task_json="$task_dir/$task_id.json"
+                    [ -f "$task_json" ] && eagle_capture_claude_task "$task_json" "$session_id" "$project"
+                fi
             fi
         fi
         ;;

package/hooks/session-end.sh

@@ -24,13 +24,15 @@ project=$(eagle_project_from_cwd "$cwd")
 
 # Final sweep: re-capture all task files to catch status changes
 # Claude Code may update task status without triggering PostToolUse
-task_dir="$HOME/.claude/tasks/$session_id"
-if [ -d "$task_dir" ]; then
-    for task_file in "$task_dir"/*.json; do
-        [ ! -f "$task_file" ] && continue
-        eagle_capture_claude_task "$task_file" "$session_id" "$project"
-    done
-    eagle_log "INFO" "SessionEnd: re-synced tasks from $task_dir"
+if eagle_validate_session_id "$session_id"; then
+    task_dir="$HOME/.claude/tasks/$session_id"
+    if [ -d "$task_dir" ]; then
+        for task_file in "$task_dir"/*.json; do
+            [ ! -f "$task_file" ] && continue
+            eagle_capture_claude_task "$task_file" "$session_id" "$project"
+        done
+        eagle_log "INFO" "SessionEnd: re-synced tasks from $task_dir"
+    fi
 fi
 
 eagle_end_session "$session_id"

package/hooks/session-start.sh

@@ -30,14 +30,15 @@ eagle_log "INFO" "SessionStart: session=$session_id project=$project source=$sou
 
 eagle_upsert_session "$session_id" "$project" "$cwd" "$model" "$source_type"
 
+# ─── Sweep stuck sessions (older than 4 hours) ─────────────
+eagle_db "UPDATE sessions SET status = 'abandoned'
+    WHERE status = 'active'
+    AND started_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-4 hours');"
+
 # ─── Build context injection ────────────────────────────────
 
-eagle_logo="███████╗░█████╗░░██████╗░██╗░░░░░███████╗  ███╗░░░███╗███████╗███╗░░░███╗
-██╔════╝██╔══██╗██╔════╝░██║░░░░░██╔════╝  ████╗░████║██╔════╝████╗░████║
-█████╗░░███████║██║░░██╗░██║░░░░░█████╗░░  ██╔████╔██║█████╗░░██╔████╔██║
-██╔══╝░░██╔══██║██║░░╚██╗██║░░░░░██╔══╝░░  ██║╚██╔╝██║██╔══╝░░██║╚██╔╝██║
-███████╗██║░░██║╚██████╔╝███████╗███████╗  ██║░╚═╝░██║███████╗██║░╚═╝░██║
-╚══════╝╚═╝░░╚═╝░╚═════╝░╚══════╝╚══════╝  ╚═╝░░░░░╚═╝╚══════╝╚═╝░░░░░╚═╝"
+eagle_logo="█▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
+██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █"
 
 context="$eagle_logo
 
@@ -107,8 +108,12 @@ Pending tasks for '$project':
     active_task=$(eagle_get_active_task "$project")
 
     if [ -z "$active_task" ] && [ -n "$first_pending" ]; then
-        # Auto-activate the next pending task
-        eagle_activate_task "$first_pending"
+        # Auto-activate the next pending task (atomic to prevent races
+        # when multiple sessions start simultaneously)
+        eagle_db "UPDATE tasks SET status = 'active', started_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+                  WHERE id = $first_pending
+                  AND status = 'pending'
+                  AND NOT EXISTS (SELECT 1 FROM tasks WHERE project = '$(eagle_sql_escape "$project")' AND status = 'active');"
         active_task=$(eagle_get_active_task "$project")
     fi
 
@@ -160,7 +165,7 @@ fi
 
 synced_tasks=$(eagle_db "SELECT subject, status FROM claude_tasks
     WHERE project = '$(eagle_sql_escape "$project")'
-    AND status IN ('in_progress', 'pending', 'todo', 'open')
+    AND status IN ('in_progress', 'pending')
     AND updated_at > datetime('now', '-7 days')
     ORDER BY updated_at DESC LIMIT 5;")
 if [ -n "$synced_tasks" ]; then
@@ -183,12 +188,8 @@ You have persistent memory powered by Eagle Mem. When you recall context from a
 IMPORTANT: At the start of your VERY NEXT response (this fires on session start, /clear, AND context compaction — always show this block, even if you think you showed it before, because prior context may have been compressed away). Show the user what Eagle Mem loaded using this exact format:
 
 \`\`\`
-███████╗░█████╗░░██████╗░██╗░░░░░███████╗  ███╗░░░███╗███████╗███╗░░░███╗
-██╔════╝██╔══██╗██╔════╝░██║░░░░░██╔════╝  ████╗░████║██╔════╝████╗░████║
-█████╗░░███████║██║░░██╗░██║░░░░░█████╗░░  ██╔████╔██║█████╗░░██╔████╔██║
-██╔══╝░░██╔══██║██║░░╚██╗██║░░░░░██╔══╝░░  ██║╚██╔╝██║██╔══╝░░██║╚██╔╝██║
-███████╗██║░░██║╚██████╔╝███████╗███████╗  ██║░╚═╝░██║███████╗██║░╚═╝░██║
-╚══════╝╚═╝░░╚═╝░╚═════╝░╚══════╝╚══════╝  ╚═╝░░░░░╚═╝╚══════╝╚═╝░░░░░╚═╝
+█▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
+██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █
 
 Project: <project name>
 Sessions: N recent | Memories: N | Tasks: N pending

package/hooks/stop.sh

@@ -48,8 +48,8 @@ if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
         else "" end
     ' "$transcript_path" 2>/dev/null)
 
-    # Strip <private>...</private> blocks before processing
-    text_content=$(echo "$text_content" | sed '/<private>/,/<\/private>/d')
+    # Strip <private>...</private> blocks before processing (case-insensitive, tolerates attributes/whitespace)
+    text_content=$(echo "$text_content" | sed -E '/<[Pp][Rr][Ii][Vv][Aa][Tt][Ee][^>]*>/,/<\/[Pp][Rr][Ii][Vv][Aa][Tt][Ee][[:space:]]*>/d')
 
     # Parse <eagle-summary> block
     if [ -n "$text_content" ] && echo "$text_content" | grep -q '<eagle-summary>' 2>/dev/null; then
@@ -108,23 +108,30 @@ fi
 # ─── Heuristic fallback: extract from tool calls ───────────
 
 if [ -z "$request" ] && [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
-    eagle_log "INFO" "Stop: no eagle-summary found, using heuristic fallback"
-
-    # Extract first user prompt as "request"
-    request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null | head -1 | cut -c1-500)
-
-    # Extract files from Read/Write/Edit tool calls
-    heuristic_reads=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
-    heuristic_writes=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Write" or .name == "Edit") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
-
-    if [ -n "$heuristic_reads" ]; then
-        files_read=$(echo "$heuristic_reads" | jq -Rsc 'split("\n") | map(select(. != ""))')
+    # Skip heuristic if we already have a summary for this session.
+    # Stop fires every turn -- without this guard, each turn creates a duplicate row.
+    existing_count=$(eagle_db "SELECT COUNT(*) FROM summaries WHERE session_id = '$(eagle_sql_escape "$session_id")';")
+    if [ "${existing_count:-0}" -gt 0 ]; then
+        eagle_log "INFO" "Stop: skipping heuristic — summary already exists for session=$session_id (count=$existing_count)"
+    else
+        eagle_log "INFO" "Stop: no eagle-summary found, using heuristic fallback"
+
+        # Extract first user prompt as "request"
+        request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null | head -1 | cut -c1-500)
+
+        # Extract files from Read/Write/Edit tool calls
+        heuristic_reads=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+        heuristic_writes=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Write" or .name == "Edit") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+
+        if [ -n "$heuristic_reads" ]; then
+            files_read=$(echo "$heuristic_reads" | jq -Rsc 'split("\n") | map(select(. != ""))')
+        fi
+        if [ -n "$heuristic_writes" ]; then
+            files_modified=$(echo "$heuristic_writes" | jq -Rsc 'split("\n") | map(select(. != ""))')
+        fi
+
+        completed="(auto-captured from tool usage)"
     fi
-    if [ -n "$heuristic_writes" ]; then
-        files_modified=$(echo "$heuristic_writes" | jq -Rsc 'split("\n") | map(select(. != ""))')
-    fi
-
-    completed="(auto-captured from tool usage)"
 fi
 
 # ─── Write to database ─────────────────────────────────────
@@ -134,8 +141,8 @@ if [ -n "$request" ] || [ -n "$completed" ] || [ -n "$learned" ]; then
     eagle_log "INFO" "Stop: summary saved for session=$session_id"
 fi
 
-# Mark active task as done if eagle-summary mentions completion
-if [ -n "$completed" ]; then
+# Mark active task as done only when Claude explicitly provided a summary
+if [ -n "$summary_block" ] && [ -n "$completed" ]; then
     completed_task_id=$(eagle_complete_active_task "$project")
     if [ -n "$completed_task_id" ]; then
         eagle_log "INFO" "Stop: marked task #$completed_task_id as done"

package/lib/common.sh

@@ -42,6 +42,13 @@ eagle_fts_sanitize() {
     printf '%s' "$1" | sed 's/[*"(){}^~:]/  /g' | sed 's/  */ /g; s/^ //; s/ $//'
 }
 
+# Validate a session ID is safe for use in file paths (no traversal).
+# Claude Code session IDs are UUIDs or hex strings — reject anything else.
+eagle_validate_session_id() {
+    local sid="$1"
+    [[ "$sid" =~ ^[A-Za-z0-9_-]+$ ]]
+}
+
 eagle_read_stdin() {
     local input=""
     if [ ! -t 0 ]; then

package/lib/db.sh

@@ -14,15 +14,15 @@ PRAGMA trusted_schema=ON;
 .output stdout"
 
 eagle_db() {
-    { echo "$EAGLE_DB_SETUP"; echo "$*"; } | sqlite3 "$EAGLE_MEM_DB" 2>/dev/null
+    { echo "$EAGLE_DB_SETUP"; echo "$*"; } | sqlite3 "$EAGLE_MEM_DB" 2>>"$EAGLE_MEM_LOG"
 }
 
 eagle_db_pipe() {
-    { echo "$EAGLE_DB_SETUP"; cat; } | sqlite3 "$EAGLE_MEM_DB" 2>/dev/null
+    { echo "$EAGLE_DB_SETUP"; cat; } | sqlite3 "$EAGLE_MEM_DB" 2>>"$EAGLE_MEM_LOG"
 }
 
 eagle_db_json() {
-    { echo "$EAGLE_DB_SETUP"; echo ".mode json"; echo "$*"; } | sqlite3 "$EAGLE_MEM_DB" 2>/dev/null
+    { echo "$EAGLE_DB_SETUP"; echo ".mode json"; echo "$*"; } | sqlite3 "$EAGLE_MEM_DB" 2>>"$EAGLE_MEM_LOG"
 }
 
 eagle_ensure_db() {
@@ -78,7 +78,7 @@ eagle_insert_summary() {
     local notes; notes=$(eagle_sql_escape "${10:-}")
 
     eagle_db_pipe <<SQL
-INSERT INTO summaries (session_id, project, request, investigated, learned, completed, next_steps, files_read, files_modified, notes)
+INSERT OR REPLACE INTO summaries (session_id, project, request, investigated, learned, completed, next_steps, files_read, files_modified, notes)
 VALUES (
     '$session_id',
     '$project',
@@ -145,19 +145,6 @@ eagle_get_next_task() {
               LIMIT 1;"
 }
 
-eagle_get_active_files() {
-    local project; project=$(eagle_sql_escape "$1")
-    local limit; limit=$(eagle_sql_int "${2:-20}")
-
-    eagle_db "SELECT json_each.value
-              FROM observations, json_each(observations.files_modified)
-              WHERE observations.project = '$project'
-              AND observations.created_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-30 days')
-              GROUP BY json_each.value
-              ORDER BY MAX(observations.created_at) DESC
-              LIMIT $limit;"
-}
-
 eagle_observation_exists() {
     local session_id; session_id=$(eagle_sql_escape "$1")
     local tool_name; tool_name=$(eagle_sql_escape "$2")
@@ -329,13 +316,6 @@ eagle_list_claude_memories() {
               LIMIT $limit;"
 }
 
-eagle_get_claude_memory() {
-    local file_path; file_path=$(eagle_sql_escape "$1")
-    eagle_db "SELECT memory_name, memory_type, description, content, file_path, updated_at, origin_session_id
-              FROM claude_memories
-              WHERE file_path = '$file_path';"
-}
-
 eagle_capture_claude_plan() {
     local file_path="$1"
     local session_id="${2:-}"
@@ -546,16 +526,25 @@ eagle_backfill_projects() {
         sid_sql=$(eagle_sql_escape "$sid")
         proj_sql=$(eagle_sql_escape "$project")
 
-        local changed
-        changed=$(eagle_db "UPDATE sessions SET project = '$proj_sql' WHERE id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+        local ch
+        ch=$(eagle_db "UPDATE sessions SET project = '$proj_sql' WHERE id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT changes();")
+        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
+        ch=$(eagle_db "UPDATE claude_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT changes();")
+        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
+        ch=$(eagle_db "UPDATE claude_memories SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT changes();")
+        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
+        ch=$(eagle_db "UPDATE claude_plans SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT changes();")
+        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
+        ch=$(eagle_db "UPDATE summaries SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
 SELECT changes();")
-        changed=$(eagle_db "UPDATE claude_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
+        ch=$(eagle_db "UPDATE observations SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
 SELECT changes();")
-        [ "${changed:-0}" -gt 0 ] && updated=$((updated + changed))
-        eagle_db "UPDATE claude_memories SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');"
-        eagle_db "UPDATE claude_plans SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');"
-        eagle_db "UPDATE summaries SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');"
-        eagle_db "UPDATE observations SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');"
+        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
     done <<< "$map"
 
     echo "$updated"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "1.4.7",
+  "version": "1.5.1",
   "description": "Lightweight persistent memory for Claude Code — SQLite + FTS5, no daemon, no bloat",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/help.sh

@@ -56,9 +56,13 @@ echo -e "    ${DOT} Mirrors Claude Code memories, plans, and tasks into FTS5-sea
 echo -e "    ${DOT} Provides task management for complex multi-step work"
 echo ""
 echo -e "  ${BOLD}Skills${RESET} ${DIM}(available inside Claude Code):${RESET}"
-echo -e "    ${CYAN}/eagle-mem-search${RESET}    Search past sessions and observations"
-echo -e "    ${CYAN}/eagle-mem-tasks${RESET}     Break work into tracked subtasks"
-echo -e "    ${CYAN}/eagle-mem-overview${RESET}  Generate a persistent project summary"
+echo -e "    ${CYAN}/eagle-mem-search${RESET}      Search past sessions and observations"
+echo -e "    ${CYAN}/eagle-mem-tasks${RESET}       Break work into tracked subtasks"
+echo -e "    ${CYAN}/eagle-mem-overview${RESET}    Generate a persistent project summary"
+echo -e "    ${CYAN}/eagle-mem-index${RESET}       Index source files for code search"
+echo -e "    ${CYAN}/eagle-mem-scan${RESET}        Scan and analyze a project"
+echo -e "    ${CYAN}/eagle-mem-memories${RESET}    Browse Claude Code memories, plans, tasks"
+echo -e "    ${CYAN}/eagle-mem-prune${RESET}       Clean up old observations and chunks"
 echo ""
 echo -e "  ${DIM}Skills use these CLI commands under the hood — no raw SQL.${RESET}"
 echo ""

package/scripts/index.sh

@@ -151,11 +151,13 @@ while IFS= read -r file; do
     file_sql=$(eagle_sql_escape "$file")
     lang_sql=$(eagle_sql_escape "$lang")
 
-    eagle_db "DELETE FROM code_chunks WHERE project = '$project_sql' AND file_path = '$file_sql';"
-
     total_lines=$(wc -l < "$full_path" 2>/dev/null | tr -d ' ')
     [ "$total_lines" -eq 0 ] && continue
 
+    # Build all INSERTs for this file, then run as a single atomic transaction
+    txn_sql="BEGIN;
+DELETE FROM code_chunks WHERE project = '$project_sql' AND file_path = '$file_sql';"
+
     start=1
     while [ "$start" -le "$total_lines" ]; do
         end=$((start + CHUNK_SIZE - 1))
@@ -164,13 +166,19 @@ while IFS= read -r file; do
         content=$(sed -n "${start},${end}p" "$full_path")
         content_sql=$(eagle_sql_escape "$content")
 
-        eagle_db "INSERT INTO code_chunks (project, file_path, language, start_line, end_line, content, mtime)
-                  VALUES ('$project_sql', '$file_sql', '$lang_sql', $start, $end, '$content_sql', $current_mtime);"
+        txn_sql+="
+INSERT INTO code_chunks (project, file_path, language, start_line, end_line, content, mtime)
+VALUES ('$project_sql', '$file_sql', '$lang_sql', $start, $end, '$content_sql', $current_mtime);"
 
         chunk_count=$((chunk_count + 1))
         start=$((end + 1))
     done
 
+    txn_sql+="
+COMMIT;"
+
+    eagle_db_pipe <<< "$txn_sql"
+
     file_count=$((file_count + 1))
 
     if [ $((file_count % 10)) -eq 0 ]; then

package/scripts/install.sh

@@ -135,15 +135,17 @@ echo ""
 echo -e "  ${BOLD}Installing Eagle Mem...${RESET}"
 echo ""
 
-mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db}
+mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db,scripts}
 
 cp "$PACKAGE_DIR"/hooks/*.sh "$EAGLE_MEM_DIR/hooks/"
 cp "$PACKAGE_DIR"/lib/*.sh "$EAGLE_MEM_DIR/lib/"
 cp "$PACKAGE_DIR"/db/*.sh "$EAGLE_MEM_DIR/db/"
 cp "$PACKAGE_DIR"/db/*.sql "$EAGLE_MEM_DIR/db/"
+cp "$PACKAGE_DIR"/scripts/statusline-em.sh "$EAGLE_MEM_DIR/scripts/" 2>/dev/null
 
 chmod +x "$EAGLE_MEM_DIR"/hooks/*.sh
 chmod +x "$EAGLE_MEM_DIR"/db/migrate.sh
+chmod +x "$EAGLE_MEM_DIR"/scripts/*.sh 2>/dev/null
 
 eagle_ok "Files copied to $EAGLE_MEM_DIR"
 
@@ -216,6 +218,53 @@ if [ -d "$PACKAGE_DIR/skills" ]; then
     done
 fi
 
+# ─── Statusline integration ───────────────────────────────
+
+EM_STATUSLINE="$EAGLE_MEM_DIR/scripts/statusline-em.sh"
+existing_sl=$(jq -r '.statusLine.command // empty' "$SETTINGS" 2>/dev/null)
+
+if [ -z "$existing_sl" ]; then
+    # No statusline configured — set up a minimal one that shows Eagle Mem
+    wrapper="$EAGLE_MEM_DIR/scripts/statusline-wrapper.sh"
+    cat > "$wrapper" << 'WRAPPER'
+#!/usr/bin/env bash
+input=$(cat)
+project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""' 2>/dev/null)
+source "$HOME/.eagle-mem/scripts/statusline-em.sh"
+eagle_mem_statusline "$project_dir"
+WRAPPER
+    chmod +x "$wrapper"
+    tmp=$(mktemp)
+    jq --arg cmd "sh $wrapper" '.statusLine = {"type": "command", "command": $cmd, "refreshInterval": 30}' "$SETTINGS" > "$tmp" && mv "$tmp" "$SETTINGS"
+    eagle_ok "Statusline ${DIM}(new — Eagle Mem indicator)${RESET}"
+elif echo "$existing_sl" | grep -q "eagle-mem"; then
+    eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
+else
+    # Existing statusline — check if it's a .sh file we can patch
+    sl_file=$(echo "$existing_sl" | sed 's/^sh //')
+    if [ -f "$sl_file" ] && ! grep -q "eagle-mem" "$sl_file"; then
+        eagle_dim "  Statusline detected: $sl_file"
+        eagle_dim "  To add Eagle Mem, add this snippet before your ASSEMBLE section:"
+        echo ""
+        eagle_dim "    # ── EAGLE MEM ──"
+        eagle_dim "    em_section=\"\""
+        eagle_dim "    em_db=\"\$HOME/.eagle-mem/memory.db\""
+        eagle_dim "    if [ -f \"\$em_db\" ]; then"
+        eagle_dim "      em_proj=\$(basename \"\$project_dir\" | sed \"s/'/''/g\")"
+        eagle_dim "      em_cnt=\$(echo \".headers off"
+        eagle_dim "    SELECT COUNT(*) FROM sessions WHERE project = '\${em_proj}';\" | sqlite3 \"\$em_db\" 2>/dev/null | tr -d '[:space:]')"
+        eagle_dim "      em_mem=\$(echo \".headers off"
+        eagle_dim "    SELECT COUNT(*) FROM claude_memories WHERE project = '\${em_proj}';\" | sqlite3 \"\$em_db\" 2>/dev/null | tr -d '[:space:]')"
+        eagle_dim "      em_cnt=\${em_cnt:-0}; em_mem=\${em_mem:-0}"
+        eagle_dim "      em_section=\$(printf \"%bEagle Mem%b %b%s%b ses %b%s%b mem\" \"\$CYAN\" \"\$R\" \"\$WHT\" \"\$em_cnt\" \"\$DIM\" \"\$WHT\" \"\$em_mem\" \"\$R\")"
+        eagle_dim "    fi"
+        echo ""
+        eagle_ok "Statusline ${DIM}(manual patch needed — instructions above)${RESET}"
+    else
+        eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
+    fi
+fi
+
 # ─── Summary ───────────────────────────────────────────────
 
 eagle_footer "Eagle Mem installed successfully."

package/scripts/overview.sh

@@ -23,27 +23,29 @@ project=""
 json_output=false
 args=()
 
+show_help() {
+    echo -e "  ${BOLD}eagle-mem overview${RESET} — Manage project overviews"
+    echo ""
+    echo -e "  ${BOLD}Usage:${RESET}"
+    echo -e "    eagle-mem overview                    ${DIM}# show current overview${RESET}"
+    echo -e "    eagle-mem overview ${CYAN}set${RESET} <text>         ${DIM}# set/update overview${RESET}"
+    echo -e "    eagle-mem overview ${CYAN}delete${RESET}             ${DIM}# delete overview${RESET}"
+    echo -e "    eagle-mem overview ${CYAN}list${RESET}               ${DIM}# list all overviews${RESET}"
+    echo ""
+    echo -e "  ${BOLD}Options:${RESET}"
+    echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
+    echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
+    echo ""
+    echo -e "  ${BOLD}Tip:${RESET} Use ${CYAN}eagle-mem scan${RESET} to auto-generate an overview from code."
+    echo ""
+    exit 0
+}
+
 while [ $# -gt 0 ]; do
     case "$1" in
         --project|-p)   project="$2"; shift 2 ;;
         --json|-j)      json_output=true; shift ;;
-        --help|-h)
-            echo -e "  ${BOLD}eagle-mem overview${RESET} — Manage project overviews"
-            echo ""
-            echo -e "  ${BOLD}Usage:${RESET}"
-            echo -e "    eagle-mem overview                    ${DIM}# show current overview${RESET}"
-            echo -e "    eagle-mem overview ${CYAN}set${RESET} <text>         ${DIM}# set/update overview${RESET}"
-            echo -e "    eagle-mem overview ${CYAN}delete${RESET}             ${DIM}# delete overview${RESET}"
-            echo -e "    eagle-mem overview ${CYAN}list${RESET}               ${DIM}# list all overviews${RESET}"
-            echo ""
-            echo -e "  ${BOLD}Options:${RESET}"
-            echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
-            echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
-            echo ""
-            echo -e "  ${BOLD}Tip:${RESET} Use ${CYAN}eagle-mem scan${RESET} to auto-generate an overview from code."
-            echo ""
-            exit 0
-            ;;
+        --help|-h)      show_help ;;
         *)  args+=("$1"); shift ;;
     esac
 done
@@ -145,23 +147,7 @@ case "$action" in
     set|update)  overview_set ;;
     delete|rm)   overview_delete ;;
     list|ls)     overview_list ;;
-    --help|-h)
-        echo -e "  ${BOLD}eagle-mem overview${RESET} — Manage project overviews"
-        echo ""
-        echo -e "  ${BOLD}Usage:${RESET}"
-        echo -e "    eagle-mem overview                    ${DIM}# show current overview${RESET}"
-        echo -e "    eagle-mem overview ${CYAN}set${RESET} <text>         ${DIM}# set/update overview${RESET}"
-        echo -e "    eagle-mem overview ${CYAN}delete${RESET}             ${DIM}# delete overview${RESET}"
-        echo -e "    eagle-mem overview ${CYAN}list${RESET}               ${DIM}# list all overviews${RESET}"
-        echo ""
-        echo -e "  ${BOLD}Options:${RESET}"
-        echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
-        echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
-        echo ""
-        echo -e "  ${BOLD}Tip:${RESET} Use ${CYAN}eagle-mem scan${RESET} to auto-generate an overview from code."
-        echo ""
-        exit 0
-        ;;
+    --help|-h) show_help ;;
     *)
         eagle_err "Unknown action: $action"
         eagle_dim "  Run 'eagle-mem overview --help' for options"

package/scripts/statusline-em.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Eagle Mem statusline section — outputs a single formatted section
+# Called by the user's statusline command to append Eagle Mem stats.
+# Usage: source this script OR call eagle_mem_statusline "$project_dir"
+
+eagle_mem_statusline() {
+    local project_dir="${1:-}"
+    local em_db="$HOME/.eagle-mem/memory.db"
+    [ -f "$em_db" ] || return
+
+    local proj
+    proj=$(basename "$project_dir")
+    [ -z "$proj" ] && return
+
+    # Escape single quotes for safe SQL interpolation
+    proj=$(printf '%s' "$proj" | sed "s/'/''/g")
+
+    local cnt mem
+    cnt=$(echo ".headers off
+SELECT COUNT(*) FROM sessions WHERE project = '${proj}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
+    mem=$(echo ".headers off
+SELECT COUNT(*) FROM claude_memories WHERE project = '${proj}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
+    cnt=${cnt:-0}; mem=${mem:-0}
+
+    local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
+    printf "%bEagle Mem%b %b%s%b ses %b%s%b mem" "$CYAN" "$R" "$WHT" "$cnt" "$DIM" "$WHT" "$mem" "$R"
+}
+
+# When run directly, read project_dir from stdin JSON (statusline format)
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    input=$(cat)
+    project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""' 2>/dev/null)
+    eagle_mem_statusline "$project_dir"
+fi

package/scripts/style.sh

@@ -32,10 +32,6 @@ eagle_warn() { echo -e "  ${YELLOW}!${RESET}  $1"; }
 eagle_err()  { echo -e "  ${RED}✗${RESET}  $1" >&2; }
 eagle_dim()  { echo -e "  ${DIM}$1${RESET}"; }
 
-eagle_step() {
-    echo -e "  ${CYAN}$1${RESET}  $2"
-}
-
 eagle_kv() {
     printf "  ${DIM}%-12s${RESET} %s\n" "$1" "$2"
 }
@@ -46,28 +42,11 @@ eagle_footer() {
     echo ""
 }
 
-eagle_art() {
-    cat << 'ART'
-        .~~~~-.
-       /    ,__`)
-      |      \o/|'-.
-      |         /  ,\
-      |        ('--./
-      /         \
-     /  ,  ,  ,  \
-     `--'--'--'--'
-ART
-}
-
 eagle_banner() {
     echo -e "${CYAN}"
     cat << 'BANNER'
-    ███████╗░█████╗░░██████╗░██╗░░░░░███████╗  ███╗░░░███╗███████╗███╗░░░███╗
-    ██╔════╝██╔══██╗██╔════╝░██║░░░░░██╔════╝  ████╗░████║██╔════╝████╗░████║
-    █████╗░░███████║██║░░██╗░██║░░░░░█████╗░░  ██╔████╔██║█████╗░░██╔████╔██║
-    ██╔══╝░░██╔══██║██║░░╚██╗██║░░░░░██╔══╝░░  ██║╚██╔╝██║██╔══╝░░██║╚██╔╝██║
-    ███████╗██║░░██║╚██████╔╝███████╗███████╗  ██║░╚═╝░██║███████╗██║░╚═╝░██║
-    ╚══════╝╚═╝░░╚═╝░╚═════╝░╚══════╝╚══════╝  ╚═╝░░░░░╚═╝╚══════╝╚═╝░░░░░╚═╝
+    █▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
+    ██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █
 BANNER
     echo -e "${RESET}"
 }

package/scripts/tasks.sh

@@ -24,28 +24,31 @@ json_output=false
 
 # Extract global options from remaining args
 args=()
+
+show_help() {
+    echo -e "  ${BOLD}eagle-mem tasks${RESET} — Manage tracked tasks"
+    echo ""
+    echo -e "  ${BOLD}Usage:${RESET}"
+    echo -e "    eagle-mem tasks                           ${DIM}# list pending tasks${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}list${RESET}                      ${DIM}# list all tasks${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}add${RESET} <title> [instructions] ${DIM}# add a task${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}done${RESET} <id>                 ${DIM}# mark task complete${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}block${RESET} <id>                ${DIM}# mark task blocked${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}context${RESET} <id> <snapshot>    ${DIM}# set task context${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}clear${RESET}                     ${DIM}# remove all done tasks${RESET}"
+    echo ""
+    echo -e "  ${BOLD}Options:${RESET}"
+    echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
+    echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
+    echo ""
+    exit 0
+}
+
 while [ $# -gt 0 ]; do
     case "$1" in
         --project|-p)   project="$2"; shift 2 ;;
         --json|-j)      json_output=true; shift ;;
-        --help|-h)
-            echo -e "  ${BOLD}eagle-mem tasks${RESET} — Manage tracked tasks"
-            echo ""
-            echo -e "  ${BOLD}Usage:${RESET}"
-            echo -e "    eagle-mem tasks                           ${DIM}# list pending tasks${RESET}"
-            echo -e "    eagle-mem tasks ${CYAN}list${RESET}                      ${DIM}# list all tasks${RESET}"
-            echo -e "    eagle-mem tasks ${CYAN}add${RESET} <title> [instructions] ${DIM}# add a task${RESET}"
-            echo -e "    eagle-mem tasks ${CYAN}done${RESET} <id>                 ${DIM}# mark task complete${RESET}"
-            echo -e "    eagle-mem tasks ${CYAN}block${RESET} <id>                ${DIM}# mark task blocked${RESET}"
-            echo -e "    eagle-mem tasks ${CYAN}context${RESET} <id> <snapshot>    ${DIM}# set task context${RESET}"
-            echo -e "    eagle-mem tasks ${CYAN}clear${RESET}                     ${DIM}# remove all done tasks${RESET}"
-            echo ""
-            echo -e "  ${BOLD}Options:${RESET}"
-            echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
-            echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
-            echo ""
-            exit 0
-            ;;
+        --help|-h)      show_help ;;
         *)  args+=("$1"); shift ;;
     esac
 done
@@ -265,24 +268,7 @@ case "$action" in
     block)      tasks_block ;;
     context)    tasks_context ;;
     clear)      tasks_clear ;;
-    --help|-h)
-        echo -e "  ${BOLD}eagle-mem tasks${RESET} — Manage tracked tasks"
-        echo ""
-        echo -e "  ${BOLD}Usage:${RESET}"
-        echo -e "    eagle-mem tasks                           ${DIM}# list pending tasks${RESET}"
-        echo -e "    eagle-mem tasks ${CYAN}list${RESET}                      ${DIM}# list all tasks${RESET}"
-        echo -e "    eagle-mem tasks ${CYAN}add${RESET} <title> [instructions] ${DIM}# add a task${RESET}"
-        echo -e "    eagle-mem tasks ${CYAN}done${RESET} <id>                 ${DIM}# mark task complete${RESET}"
-        echo -e "    eagle-mem tasks ${CYAN}block${RESET} <id>                ${DIM}# mark task blocked${RESET}"
-        echo -e "    eagle-mem tasks ${CYAN}context${RESET} <id> <snapshot>    ${DIM}# set task context${RESET}"
-        echo -e "    eagle-mem tasks ${CYAN}clear${RESET}                     ${DIM}# remove all done tasks${RESET}"
-        echo ""
-        echo -e "  ${BOLD}Options:${RESET}"
-        echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
-        echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
-        echo ""
-        exit 0
-        ;;
+    --help|-h) show_help ;;
     *)
         eagle_err "Unknown action: $action"
         eagle_dim "  Run 'eagle-mem tasks --help' for options"

package/scripts/uninstall.sh

@@ -36,15 +36,10 @@ fi
 # ─── Remove skill symlinks ────────────────────────────────
 
 if [ -d "$EAGLE_SKILLS_DIR" ]; then
-    for skill in eagle-mem-search eagle-mem-tasks eagle-mem-overview; do
-        target="$EAGLE_SKILLS_DIR/$skill"
-        if [ -L "$target" ]; then
-            rm "$target"
-            eagle_ok "Skill removed: $skill"
-        elif [ -d "$target" ]; then
-            rm -rf "$target"
-            eagle_ok "Skill removed: $skill"
-        fi
+    for target in "$EAGLE_SKILLS_DIR"/eagle-mem-*; do
+        [ -L "$target" ] || [ -d "$target" ] || continue
+        rm -rf "$target"
+        eagle_ok "Skill removed: $(basename "$target")"
     done
 fi
 

package/skills/eagle-mem-index/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: eagle-mem-index
+description: >
+  Index source files into FTS5-searchable chunks for code-level search. Use when: 'eagle index',
+  'index this project', 'index codebase', 'eagle mem index', 'make code searchable',
+  'update code index'. Uses the eagle-mem CLI.
+---
+
+# Eagle Mem — Index
+
+Chunk and index source files into Eagle Mem's FTS5 search index. Enables code-level search across sessions.
+
+## What it does
+
+- Walks the project directory for source files
+- Splits each file into chunks (default 80 lines)
+- Stores chunks in the `code_chunks` table with FTS5 indexing
+- Incremental: only re-indexes files modified since the last run (via mtime)
+
+## Commands
+
+### Index current project
+
+```bash
+eagle-mem index .
+```
+
+### Index a specific directory
+
+```bash
+eagle-mem index /path/to/project
+```
+
+## When to use
+
+- After initial project setup to make code searchable
+- After pulling significant changes
+- When `/eagle-mem-search` isn't finding code you know exists
+
+## How it integrates
+
+Once indexed, the UserPromptSubmit hook can surface relevant code chunks when you ask questions. The `/eagle-mem-search` skill also searches indexed code.
+
+## Notes
+
+- Respects .gitignore — only indexes tracked/untracked source files
+- Skips binary files and files over 1MB
+- Chunk size is configurable via `EAGLE_MEM_CHUNK_SIZE` env var (default: 80 lines)
+- Re-running is safe — unchanged files are skipped automatically

package/skills/eagle-mem-memories/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: eagle-mem-memories
+description: >
+  View and sync Claude Code auto-memories, plans, and tasks mirrored in Eagle Mem. Use when:
+  'eagle memories', 'show memories', 'list memories', 'sync memories', 'eagle mem memories',
+  'what does claude remember', 'show plans', 'show tasks'. Uses the eagle-mem CLI.
+---
+
+# Eagle Mem — Memories
+
+View, search, and sync Claude Code's auto-memories, plans, and tasks that are mirrored into Eagle Mem's SQLite + FTS5 database.
+
+## Commands
+
+### List mirrored memories
+
+```bash
+eagle-mem memories
+eagle-mem memories list
+```
+
+### Search memories
+
+```bash
+eagle-mem memories search "auth middleware"
+```
+
+### Show a specific memory
+
+```bash
+eagle-mem memories show <name>
+```
+
+### List mirrored plans
+
+```bash
+eagle-mem memories plans
+```
+
+### List mirrored tasks
+
+```bash
+eagle-mem memories tasks
+```
+
+### Sync all from Claude Code
+
+Backfill all memories, plans, and tasks from Claude Code's filesystem into Eagle Mem:
+
+```bash
+eagle-mem memories sync
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-p, --project <name>` | Target a specific project (default: current directory) |
+| `-n, --limit <N>` | Max results (default: 20) |
+| `-j, --json` | Output as JSON |
+
+## How it works
+
+Eagle Mem automatically mirrors Claude Code writes via the PostToolUse hook:
+- **Memories** from `~/.claude/projects/*/memory/*.md`
+- **Plans** from `~/.claude/plans/*.md`
+- **Tasks** from Claude Code's TaskCreate/TaskUpdate calls
+
+The `sync` command does a full backfill for anything the hooks missed.
+
+## When to use
+
+- To check what Claude Code has auto-saved about this project
+- To search across memories from multiple projects
+- After installing Eagle Mem on an existing project (run `sync` to backfill)

package/skills/eagle-mem-prune/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: eagle-mem-prune
+description: >
+  Clean up old observations and orphaned data to keep Eagle Mem's database lean. Use when:
+  'eagle prune', 'clean up memory', 'prune database', 'eagle mem prune', 'database too large',
+  'remove old data'. Uses the eagle-mem CLI.
+---
+
+# Eagle Mem — Prune
+
+Remove old observations, orphaned code chunks, and stale data from Eagle Mem's database.
+
+## Commands
+
+### Prune with defaults (90 days)
+
+```bash
+eagle-mem prune
+```
+
+### Prune older than N days
+
+```bash
+eagle-mem prune --days 30
+```
+
+### Dry run (see what would be removed)
+
+```bash
+eagle-mem prune --dry-run
+```
+
+### Prune a specific project
+
+```bash
+eagle-mem prune --project my-app
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-d, --days <N>` | Remove observations older than N days (default: 90) |
+| `-p, --project <name>` | Target a specific project |
+| `-n, --dry-run` | Show what would be pruned without deleting |
+
+## What gets pruned
+
+- **Old observations** — tool-use records older than the threshold
+- **Orphaned code chunks** — chunks for files that no longer exist
+
+## What is preserved
+
+- Session records (never deleted)
+- All summaries
+- Claude Code mirrored memories and plans
+- Task records
+
+## When to use
+
+- Database feels slow or is growing large
+- After removing a project or major refactor
+- Periodic maintenance (monthly is fine for most users)

package/skills/eagle-mem-scan/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: eagle-mem-scan
+description: >
+  Scan and analyze a project's codebase to generate a persistent overview. Use when: 'eagle scan',
+  'scan this project', 'analyze codebase', 'eagle mem scan', 'generate overview from code',
+  'what does this project look like'. Uses the eagle-mem CLI.
+---
+
+# Eagle Mem — Scan
+
+Analyze the current project's codebase and generate a concise overview that Eagle Mem injects at the start of every session.
+
+## What it does
+
+Scans the project directory to collect:
+- File count, directory structure, languages used
+- Entry points, config files, test presence
+- Framework/library detection from package.json, go.mod, etc.
+
+Then saves a compact overview to the database.
+
+## Commands
+
+### Scan current project
+
+```bash
+eagle-mem scan .
+```
+
+### Scan a specific directory
+
+```bash
+eagle-mem scan /path/to/project
+```
+
+## When to use
+
+- First time opening a project with Eagle Mem
+- After major restructuring (new packages, renamed dirs)
+- When the current overview feels stale or wrong
+
+The overview is automatically injected by the SessionStart hook, so every fresh session starts with project context.
+
+## Notes
+
+- Scans respect .gitignore — only tracked/untracked files are analyzed
+- The overview is stored once per project and updated in place
+- Keep the generated overview factual — it supplements session summaries