eagle-mem 4.9.6 → 4.9.7

package/scripts/search.sh

@@ -34,6 +34,7 @@ show_help() {
     echo -e "    ${CYAN}-n, --limit${RESET} <N>         Max results (default: 10)"
     echo -e "    ${CYAN}-a, --all${RESET}               Search across all projects"
     echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
+    echo -e "    ${CYAN}--raw, --debug${RESET}          Show raw IDs and detailed observation rows"
     echo ""
     exit 0
 }
@@ -45,6 +46,7 @@ project=""
 limit=10
 session_id=""
 json_output=false
+raw_output=false
 query=""
 cross_project=false
 
@@ -61,6 +63,7 @@ while [ $# -gt 0 ]; do
         --limit|-n)          limit="$2"; shift 2 ;;
         --all|-a)            cross_project=true; shift ;;
         --json|-j)           json_output=true; shift ;;
+        --raw|--debug)       raw_output=true; shift ;;
         --help|-h)  show_help ;;
         -*)
             eagle_err "Unknown option: $1"
@@ -93,23 +96,57 @@ search_keyword() {
     fi
 
     if [ "$json_output" = true ]; then
-        eagle_db_json "SELECT s.id, s.project, s.agent, s.request, s.completed, s.learned, s.created_at
+        eagle_db_json "SELECT s.id, s.project, s.agent, s.request, s.completed, s.learned, s.created_at,
+                              CASE
+                                WHEN julianday('now') - julianday(s.created_at) <= 14 THEN 'Fresh'
+                                WHEN julianday('now') - julianday(s.created_at) <= 45 THEN 'Recent'
+                                ELSE 'Older'
+                              END AS freshness
                        FROM summaries s
                        JOIN summaries_fts f ON f.rowid = s.id
                        WHERE summaries_fts MATCH '$q'
+                       AND COALESCE(s.request, '') NOT LIKE '%<local-command-caveat>%'
+                       AND COALESCE(s.request, '') NOT LIKE '# AGENTS.md instructions%'
+                       AND COALESCE(s.request, '') NOT LIKE '<environment_context>%'
+                       AND COALESCE(s.request, '') NOT LIKE '<subagent_notification>%'
+                       AND COALESCE(s.request, '') NOT LIKE '</subagent_notification>%'
                        $where_project
-                       ORDER BY rank
+                       ORDER BY
+                         CASE
+                           WHEN julianday('now') - julianday(s.created_at) <= 14 THEN 0
+                           WHEN julianday('now') - julianday(s.created_at) <= 45 THEN 1
+                           ELSE 2
+                         END,
+                         s.created_at DESC,
+                         rank
                        LIMIT $limit;"
         return
     fi
 
     local results
-    results=$(eagle_db "SELECT s.id, s.project, s.agent, s.request, s.completed, s.learned, s.created_at
+    results=$(eagle_db "SELECT s.id, s.project, s.agent, s.request, s.completed, s.learned, s.created_at,
+                               CASE
+                                 WHEN julianday('now') - julianday(s.created_at) <= 14 THEN 'Fresh'
+                                 WHEN julianday('now') - julianday(s.created_at) <= 45 THEN 'Recent'
+                                 ELSE 'Older'
+                               END AS freshness
                         FROM summaries s
                         JOIN summaries_fts f ON f.rowid = s.id
                         WHERE summaries_fts MATCH '$q'
+                        AND COALESCE(s.request, '') NOT LIKE '%<local-command-caveat>%'
+                        AND COALESCE(s.request, '') NOT LIKE '# AGENTS.md instructions%'
+                        AND COALESCE(s.request, '') NOT LIKE '<environment_context>%'
+                        AND COALESCE(s.request, '') NOT LIKE '<subagent_notification>%'
+                        AND COALESCE(s.request, '') NOT LIKE '</subagent_notification>%'
                         $where_project
-                        ORDER BY rank
+                        ORDER BY
+                          CASE
+                            WHEN julianday('now') - julianday(s.created_at) <= 14 THEN 0
+                            WHEN julianday('now') - julianday(s.created_at) <= 45 THEN 1
+                            ELSE 2
+                          END,
+                          s.created_at DESC,
+                          rank
                         LIMIT $limit;")
 
     if [ -z "$results" ]; then
@@ -118,17 +155,18 @@ search_keyword() {
     fi
 
     echo ""
-    while IFS='|' read -r sid sproj sagent req completed learned created_at; do
+    local idx=1
+    while IFS='|' read -r sid sproj sagent req completed learned created_at freshness; do
         [ -z "$sid" ] && continue
-        echo -e "  ${BOLD}#$sid${RESET}  ${DIM}$created_at${RESET}"
+        echo -e "  ${BOLD}${idx}. ${req:-Memory match}${RESET}"
+        echo -e "  ${DIM}source:${RESET} $(eagle_agent_label "$sagent")  ${DIM}date:${RESET} $created_at  ${DIM}freshness:${RESET} $freshness"
         if [ "$cross_project" = true ]; then
             echo -e "  ${DIM}project:${RESET} $sproj"
         fi
-        echo -e "  ${DIM}source:${RESET} $(eagle_agent_label "$sagent")"
-        [ -n "$req" ] && echo -e "  ${CYAN}Request:${RESET} $req"
         [ -n "$completed" ] && echo -e "  ${GREEN}Done:${RESET} $completed"
         [ -n "$learned" ] && echo -e "  ${YELLOW}Learned:${RESET} $learned"
         echo ""
+        idx=$((idx + 1))
     done <<< "$results"
 }
 
@@ -163,21 +201,45 @@ search_timeline() {
     echo -e "  ${DIM}─────────────────────────────────────${RESET}"
     echo ""
 
+    local idx=1
     while IFS='|' read -r sid sagent req completed learned next_steps created_at; do
         [ -z "$sid" ] && continue
-        echo -e "  ${BOLD}#$sid${RESET}  ${DIM}$created_at${RESET}"
+        if [ "$raw_output" = true ]; then
+            echo -e "  ${BOLD}#$sid${RESET}  ${DIM}$created_at${RESET}"
+        else
+            echo -e "  ${BOLD}${idx}. Session summary${RESET}  ${DIM}$created_at${RESET}"
+        fi
         echo -e "  ${DIM}source:${RESET} $(eagle_agent_label "$sagent")"
         [ -n "$req" ] && echo -e "  ${CYAN}Request:${RESET} $req"
         [ -n "$completed" ] && echo -e "  ${GREEN}Done:${RESET} $completed"
         [ -n "$learned" ] && echo -e "  ${YELLOW}Learned:${RESET} $learned"
         [ -n "$next_steps" ] && echo -e "  ${DIM}Next:${RESET} $next_steps"
         echo ""
+        idx=$((idx + 1))
     done <<< "$results"
+    if [ "$raw_output" = false ]; then
+        eagle_dim "Run with --raw to show summary IDs."
+    fi
 }
 
 # ─── Session details ──────────────────────────────────────
 
 search_session() {
+    if [ -z "$session_id" ]; then
+        eagle_err "Usage: eagle-mem search --session <session-id-or-summary-id>"
+        exit 1
+    fi
+
+    local lookup_sql resolved_session
+    lookup_sql=$(eagle_sql_escape "$session_id")
+    case "$session_id" in
+        *[!0-9]*) ;;
+        *)
+            resolved_session=$(eagle_db "SELECT session_id FROM summaries WHERE id = '$lookup_sql' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
+            [ -n "$resolved_session" ] && session_id="$resolved_session"
+            ;;
+    esac
+
     local sid_sql; sid_sql=$(eagle_sql_escape "$session_id")
 
     if [ "$json_output" = true ]; then
@@ -188,33 +250,111 @@ search_session() {
         return
     fi
 
-    local results
-    results=$(eagle_db "SELECT o.agent, o.tool_name, o.tool_input_summary, o.files_read, o.files_modified, o.created_at
-                        FROM observations o
-                        WHERE o.session_id = '$sid_sql'
-                        ORDER BY o.created_at ASC;")
+    local results_json
+    results_json=$(eagle_db_json "SELECT o.agent, o.tool_name, o.tool_input_summary, o.files_read, o.files_modified, o.created_at
+                                  FROM observations o
+                                  WHERE o.session_id = '$sid_sql'
+                                  ORDER BY o.created_at ASC;")
 
-    if [ -z "$results" ]; then
+    if [ -z "$results_json" ] || [ "$(printf '%s' "$results_json" | jq 'length' 2>/dev/null)" = "0" ]; then
         eagle_dim "No observations found for session '$session_id'"
         return
     fi
 
+    if [ "$raw_output" = true ]; then
+        echo ""
+        echo -e "  ${BOLD}Session${RESET} ${DIM}$session_id${RESET}"
+        echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+        echo ""
+
+        printf '%s' "$results_json" | jq -c '.[]' | while IFS= read -r row; do
+            oagent=$(printf '%s' "$row" | jq -r '.agent // ""')
+            tool_name=$(printf '%s' "$row" | jq -r '.tool_name // ""')
+            summary=$(printf '%s' "$row" | jq -r '.tool_input_summary // ""')
+            created_at=$(printf '%s' "$row" | jq -r '.created_at // ""')
+            [ -z "$tool_name" ] && continue
+            local icon="$DOT"
+            case "$tool_name" in
+                Read) icon="${CYAN}R${RESET}" ;;
+                Write) icon="${GREEN}W${RESET}" ;;
+                Edit) icon="${YELLOW}E${RESET}" ;;
+                Bash|exec_command|shell_command|unified_exec) icon="${BLUE}\$${RESET}" ;;
+            esac
+            echo -e "  ${icon}  ${DIM}$created_at $(eagle_agent_label "$oagent")${RESET}  $summary"
+        done
+        echo ""
+        return
+    fi
+
+    local first_seen last_seen total_obs agent_counts tool_counts
+    first_seen=$(eagle_db "SELECT MIN(created_at) FROM observations WHERE session_id = '$sid_sql';")
+    last_seen=$(eagle_db "SELECT MAX(created_at) FROM observations WHERE session_id = '$sid_sql';")
+    total_obs=$(printf '%s' "$results_json" | jq 'length' 2>/dev/null)
+    agent_counts=$(eagle_db "SELECT agent || ':' || COUNT(*) FROM observations WHERE session_id = '$sid_sql' GROUP BY agent ORDER BY COUNT(*) DESC;")
+    tool_counts=$(eagle_db "SELECT tool_name || ':' || COUNT(*) FROM observations WHERE session_id = '$sid_sql' GROUP BY tool_name ORDER BY COUNT(*) DESC LIMIT 8;")
+
     echo ""
-    echo -e "  ${BOLD}Session${RESET} ${DIM}$session_id${RESET}"
+    echo -e "  ${BOLD}Session Activity${RESET}"
     echo -e "  ${DIM}─────────────────────────────────────${RESET}"
     echo ""
-
-    while IFS='|' read -r oagent tool_name summary files_r files_m created_at; do
+    eagle_kv "Observations:" "${total_obs:-0}"
+    [ -n "$first_seen" ] && eagle_kv "Started:" "$first_seen"
+    [ -n "$last_seen" ] && eagle_kv "Last seen:" "$last_seen"
+    if [ -n "$agent_counts" ]; then
+        local agents_display=""
+        while IFS=':' read -r a count; do
+            [ -z "$a" ] && continue
+            [ -n "$agents_display" ] && agents_display+=", "
+            agents_display+="$(eagle_agent_label "$a") $count"
+        done <<< "$agent_counts"
+        [ -n "$agents_display" ] && eagle_kv "Agents:" "$agents_display"
+    fi
+    if [ -n "$tool_counts" ]; then
+        local tools_display=""
+        while IFS=':' read -r t count; do
+            [ -z "$t" ] && continue
+            [ -n "$tools_display" ] && tools_display+=", "
+            tools_display+="$t $count"
+        done <<< "$tool_counts"
+        [ -n "$tools_display" ] && eagle_kv "Tools:" "$tools_display"
+    fi
+    echo ""
+    echo -e "  ${BOLD}Recent activity${RESET}"
+
+    printf '%s' "$results_json" | jq -c --argjson limit "$limit" '.[-$limit:][]' | while IFS= read -r row; do
+        oagent=$(printf '%s' "$row" | jq -r '.agent // ""')
+        tool_name=$(printf '%s' "$row" | jq -r '.tool_name // ""')
+        summary=$(printf '%s' "$row" | jq -r '.tool_input_summary // ""')
+        files_r=$(printf '%s' "$row" | jq -r '.files_read // "[]"')
+        files_m=$(printf '%s' "$row" | jq -r '.files_modified // "[]"')
+        created_at=$(printf '%s' "$row" | jq -r '.created_at // ""')
         [ -z "$tool_name" ] && continue
-        local icon="$DOT"
+        local label detail
+        label="$tool_name"
+        detail=$(eagle_trim_text "$summary" 120)
         case "$tool_name" in
-            Read) icon="${CYAN}R${RESET}" ;;
-            Write) icon="${GREEN}W${RESET}" ;;
-            Edit) icon="${YELLOW}E${RESET}" ;;
-            Bash) icon="${BLUE}\$${RESET}" ;;
+            Read)
+                label="Read"
+                detail=$(printf '%s' "$files_r" | jq -r 'fromjson? | .[0] // empty' 2>/dev/null)
+                [ -n "$detail" ] && detail=$(basename "$detail")
+                ;;
+            Write|Edit)
+                label="$tool_name"
+                detail=$(printf '%s' "$files_m" | jq -r 'fromjson? | .[0] // empty' 2>/dev/null)
+                [ -n "$detail" ] && detail=$(basename "$detail")
+                ;;
+            apply_patch)
+                label="Patch"
+                ;;
+            Bash|exec_command|shell_command|unified_exec)
+                label="Command"
+                ;;
         esac
-        echo -e "  ${icon}  ${DIM}$created_at $(eagle_agent_label "$oagent")${RESET}  $summary"
-    done <<< "$results"
+        [ -z "$detail" ] && detail="$(eagle_agent_label "$oagent") activity"
+        echo -e "  ${DOT} ${DIM}$created_at${RESET} ${BOLD}$label:${RESET} $detail"
+    done
+    echo ""
+    eagle_dim "Run with --raw for full observation rows and session ID."
     echo ""
 }
 
@@ -355,21 +495,45 @@ search_memories() {
         fi
 
         if [ "$json_output" = true ]; then
-            eagle_db_json "SELECT m.memory_name, m.memory_type, m.description, m.project, m.updated_at, m.origin_agent
+            eagle_db_json "SELECT m.memory_name, m.memory_type, m.description, m.project, m.updated_at, m.origin_agent,
+                                  CASE
+                                    WHEN julianday('now') - julianday(m.updated_at) <= 14 THEN 'Fresh'
+                                    WHEN julianday('now') - julianday(m.updated_at) <= 45 THEN 'Recent'
+                                    ELSE 'Older'
+                                  END AS freshness
                            FROM agent_memories m
                            JOIN agent_memories_fts f ON f.rowid = m.id
                            $where_match
-                           ORDER BY rank
+                           ORDER BY
+                             CASE
+                               WHEN julianday('now') - julianday(m.updated_at) <= 14 THEN 0
+                               WHEN julianday('now') - julianday(m.updated_at) <= 45 THEN 1
+                               ELSE 2
+                             END,
+                             m.updated_at DESC,
+                             rank
                            LIMIT $limit;"
             return
         fi
 
         local results
-        results=$(eagle_db "SELECT m.memory_name, m.memory_type, m.description, m.project, m.updated_at, m.origin_agent
+        results=$(eagle_db "SELECT m.memory_name, m.memory_type, m.description, m.project, m.updated_at, m.origin_agent,
+                                   CASE
+                                     WHEN julianday('now') - julianday(m.updated_at) <= 14 THEN 'Fresh'
+                                     WHEN julianday('now') - julianday(m.updated_at) <= 45 THEN 'Recent'
+                                     ELSE 'Older'
+                                   END AS freshness
                             FROM agent_memories m
                             JOIN agent_memories_fts f ON f.rowid = m.id
                             $where_match
-                            ORDER BY rank
+                            ORDER BY
+                              CASE
+                                WHEN julianday('now') - julianday(m.updated_at) <= 14 THEN 0
+                                WHEN julianday('now') - julianday(m.updated_at) <= 45 THEN 1
+                                ELSE 2
+                              END,
+                              m.updated_at DESC,
+                              rank
                             LIMIT $limit;")
 
         if [ -z "$results" ]; then
@@ -378,9 +542,9 @@ search_memories() {
         fi
 
         echo ""
-        while IFS='|' read -r mname mtype mdesc mproj mupdated morigin; do
+        while IFS='|' read -r mname mtype mdesc mproj mupdated morigin freshness; do
             [ -z "$mname" ] && continue
-            echo -e "  ${BOLD}$mname${RESET}  ${DIM}[$mtype][$(eagle_agent_label "$morigin")]${RESET}"
+            echo -e "  ${BOLD}$mname${RESET}  ${DIM}[$mtype][$(eagle_agent_label "$morigin")][$freshness]${RESET}"
             [ "$cross_project" = true ] && echo -e "  ${DIM}project:${RESET} $mproj"
             [ -n "$mdesc" ] && echo -e "  $mdesc"
             echo ""

package/scripts/statusline-em.sh

@@ -1,35 +1,79 @@
 #!/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 renderers.
+# Usage:
+#   source this file and call eagle_mem_statusline "$project_dir" "$session_id" "$input"
+#   printf '%s' "$input" | bash ~/.eagle-mem/scripts/statusline-em.sh --hud
 
-eagle_mem_statusline() {
+_eagle_statusline_load_common() {
+    local script_dir
+    script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    . "$script_dir/../lib/common.sh"
+}
+
+_eagle_statusline_relative_time() {
+    local raw="${1:-}"
+    [ -n "$raw" ] && [ "$raw" != "never" ] || { printf 'never\n'; return; }
+
+    local last_epoch now_epoch diff_sec
+    last_epoch=$(date -j -u -f "%Y-%m-%dT%H:%M:%S" "${raw%%.*}" "+%s" 2>/dev/null \
+        || date -u -d "$raw" "+%s" 2>/dev/null \
+        || true)
+    now_epoch=$(date "+%s" 2>/dev/null || true)
+    if [ -z "$last_epoch" ] || [ -z "$now_epoch" ]; then
+        printf '%s\n' "$raw"
+        return
+    fi
+
+    diff_sec=$((now_epoch - last_epoch))
+    if [ "$diff_sec" -lt 60 ]; then
+        printf 'just now\n'
+    elif [ "$diff_sec" -lt 3600 ]; then
+        printf '%sm ago\n' "$((diff_sec / 60))"
+    elif [ "$diff_sec" -lt 86400 ]; then
+        printf '%sh ago\n' "$((diff_sec / 3600))"
+    else
+        printf '%sd ago\n' "$((diff_sec / 86400))"
+    fi
+}
+
+eagle_mem_statusline_stats() {
     local project_dir="${1:-}"
     local session_id="${2:-}"
     local statusline_input="${3:-}"
+    local current_dir="${4:-}"
     local em_db="$HOME/.eagle-mem/memory.db"
     [ -f "$em_db" ] || return
 
-    local SCRIPT_DIR; SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-    . "$SCRIPT_DIR/../lib/common.sh"
+    _eagle_statusline_load_common
+
     local sqlite_bin
     sqlite_bin=$(eagle_sqlite_path)
     [ -n "$sqlite_bin" ] || return
 
-    local proj
+    if [ -n "$statusline_input" ]; then
+        [ -z "$session_id" ] && session_id=$(printf '%s' "$statusline_input" | jq -r '.session_id // .session.id // empty' 2>/dev/null)
+        [ -z "$project_dir" ] && project_dir=$(printf '%s' "$statusline_input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // empty' 2>/dev/null)
+        [ -z "$current_dir" ] && current_dir=$(printf '%s' "$statusline_input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
+    fi
     [ -z "$project_dir" ] && project_dir="$(pwd)"
-    proj=$(eagle_project_from_statusline_input "$statusline_input" "$project_dir" "$project_dir" "$session_id")
-    [ -z "$proj" ] && return
+    [ -z "$current_dir" ] && current_dir="$project_dir"
 
-    proj=$(eagle_sql_escape "$proj")
+    local project_key project_sql stats sessions memories last_raw turns version latest
+    project_key=$(eagle_project_from_statusline_input "$statusline_input" "$project_dir" "$current_dir" "$session_id")
+    [ -n "$project_key" ] || return
+    project_sql=$(eagle_sql_escape "$project_key")
+
+    stats=$("$sqlite_bin" "$em_db" "SELECT
+        COUNT(*) || '|' ||
+        (SELECT COUNT(*) FROM agent_memories WHERE project = '$project_sql') || '|' ||
+        COALESCE(MAX(COALESCE(last_activity_at, started_at)), 'never')
+        FROM sessions
+        WHERE project = '$project_sql';" 2>/dev/null)
+    IFS='|' read -r sessions memories last_raw <<< "${stats:-0|0|never}"
+    sessions=${sessions:-0}
+    memories=${memories:-0}
+    last_raw=${last_raw:-never}
 
-    local version cnt mem turns
-    version=$(tr -d '[:space:]' < "$HOME/.eagle-mem/.version" 2>/dev/null)
-    [ -z "$version" ] && version="?"
-    cnt=$(echo ".headers off
-SELECT COUNT(*) FROM sessions WHERE project = '${proj}';" | "$sqlite_bin" "$em_db" 2>/dev/null | tr -d '[:space:]')
-    mem=$(echo ".headers off
-SELECT COUNT(*) FROM agent_memories WHERE project = '${proj}';" | "$sqlite_bin" "$em_db" 2>/dev/null | tr -d '[:space:]')
     if [ -n "$session_id" ] && [ -f "$HOME/.eagle-mem/.turn-counter.${session_id}" ]; then
         turns=$(tr -d '[:space:]' < "$HOME/.eagle-mem/.turn-counter.${session_id}" 2>/dev/null)
     else
@@ -40,26 +84,85 @@ SELECT COUNT(*) FROM agent_memories WHERE project = '${proj}';" | "$sqlite_bin"
             done \
             | awk '($1+0)>max{max=$1+0} END{print max+0}')
     fi
-    cnt=${cnt:-0}; mem=${mem:-0}
     turns=${turns:-0}
 
+    version=$(tr -d '[:space:]' < "$HOME/.eagle-mem/.version" 2>/dev/null)
+    latest=$(tr -d '[:space:]' < "$HOME/.eagle-mem/.latest-version" 2>/dev/null)
+    [ -z "$version" ] && version="?"
+    [ -z "$latest" ] && latest="$version"
+
+    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$project_key" "$version" "$latest" "$sessions" "$memories" "$turns" "$last_raw"
+}
+
+eagle_mem_statusline() {
+    local stats project_key version latest sessions memories turns last_raw
+    stats=$(eagle_mem_statusline_stats "${1:-}" "${2:-}" "${3:-}" "${4:-}") || return
+    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw <<< "$stats"
+
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
-    printf "%bEM%b %bv%s%b ses %b%s%b mem %b%s%b turns %b%s%b" \
+    printf "%bEagle%b %bv%s%b | %b%s%b sessions | %b%s%b memories | turn %b%s%b" \
         "$CYAN" "$R" \
         "$WHT" "$version" "$DIM" \
-        "$WHT" "$cnt" "$DIM" \
-        "$WHT" "$mem" "$DIM" \
-        "$WHT" "$turns" "$R"
+        "$WHT" "${sessions:-0}" "$DIM" \
+        "$WHT" "${memories:-0}" "$DIM" \
+        "$WHT" "${turns:-0}" "$R"
+}
+
+eagle_mem_statusline_hud() {
+    local stats project_key version latest sessions memories turns last_raw last_label
+    stats=$(eagle_mem_statusline_stats "${1:-}" "${2:-}" "${3:-}" "${4:-}") || return
+    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw <<< "$stats"
+    last_label=$(_eagle_statusline_relative_time "$last_raw")
+
+    local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
+    local GRN='\033[92m' ORG='\033[38;5;214m' RED='\033[91m'
+    local turn_color pressure_label em_ver newest
+
+    turns=${turns:-0}
+    if [ "$turns" -ge 30 ] 2>/dev/null; then
+        turn_color="$RED"; pressure_label="CRITICAL"
+    elif [ "$turns" -ge 20 ] 2>/dev/null; then
+        turn_color="$ORG"; pressure_label="HIGH"
+    else
+        turn_color="$GRN"; pressure_label="OK"
+    fi
+
+    em_ver="v${version:-?}"
+    newest=$(printf '%s\n' "${version:-}" "${latest:-}" | sort -V 2>/dev/null | tail -1 || true)
+    if [ -n "$latest" ] && [ -n "$newest" ] && [ "$newest" != "$version" ]; then
+        em_ver="${em_ver} ${ORG}↑${latest}${R}"
+    elif [ -n "$latest" ] && [ "$latest" = "$version" ]; then
+        em_ver="${em_ver} ${GRN}✓${R}"
+    fi
+
+    printf "%bEagle Mem%b %b %b│%b %bSessions:%b %b%s%b %b│%b %bMemories:%b %b%s%b %b│%b %bTurns:%b %b%s/30%b %b(%s)%b %b│%b %bUpdated:%b %b%s%b" \
+        "$CYAN" "$R" "$em_ver" \
+        "$DIM" "$R" "$DIM" "$R" "$WHT" "${sessions:-0}" "$R" "$DIM" "$R" \
+        "$DIM" "$R" "$WHT" "${memories:-0}" "$R" "$DIM" "$R" \
+        "$DIM" "$R" "$turn_color" "$turns" "$R" "$turn_color" "$pressure_label" "$R" "$DIM" "$R" \
+        "$DIM" "$R" "$WHT" "$last_label" "$R"
 }
 
-# When run directly, read project_dir from stdin JSON (statusline format)
 if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    mode="${1:-compact}"
     if [ -t 0 ]; then
         input=""
     else
         input=$(cat)
     fi
-    project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // empty' 2>/dev/null)
-    session_id=$(echo "$input" | jq -r '.session_id // .session.id // empty' 2>/dev/null)
-    eagle_mem_statusline "${project_dir:-$(pwd)}" "$session_id" "$input"
+    project_dir=$(printf '%s' "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // empty' 2>/dev/null)
+    current_dir=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
+    session_id=$(printf '%s' "$input" | jq -r '.session_id // .session.id // empty' 2>/dev/null)
+
+    case "$mode" in
+        --hud|hud)
+            eagle_mem_statusline_hud "${project_dir:-$(pwd)}" "$session_id" "$input" "$current_dir"
+            ;;
+        --stats|stats)
+            eagle_mem_statusline_stats "${project_dir:-$(pwd)}" "$session_id" "$input" "$current_dir"
+            ;;
+        *)
+            eagle_mem_statusline "${project_dir:-$(pwd)}" "$session_id" "$input" "$current_dir"
+            ;;
+    esac
 fi

package/scripts/uninstall.sh

@@ -13,12 +13,32 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$LIB_DIR/codex-hooks.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
+dry_run=false
+
+for arg in "$@"; do
+    case "$arg" in
+        --dry-run|--check)
+            dry_run=true
+            ;;
+        --help|-h)
+            echo "Usage: eagle-mem uninstall [--dry-run]"
+            exit 0
+            ;;
+    esac
+done
 
 eagle_header "Uninstall"
+eagle_uninstall_change_plan
+
+if [ "$dry_run" = true ]; then
+    eagle_footer "Dry run complete. No files changed."
+    exit 0
+fi
 
 # ─── Remove hooks from settings.json ──────────────────────
 
 if [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
+    settings_backup=$(eagle_backup_user_file "$SETTINGS" 2>/dev/null || true)
     for event in SessionStart Stop PostToolUse PreToolUse SessionEnd UserPromptSubmit; do
         if jq -e ".hooks.${event}" "$SETTINGS" &>/dev/null; then
             tmp=$(mktemp)
@@ -30,16 +50,55 @@ if [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
     tmp=$(mktemp)
     jq 'if .hooks == {} then del(.hooks) else . end' "$SETTINGS" > "$tmp" && mv "$tmp" "$SETTINGS"
     eagle_ok "Hooks removed from settings.json"
+    [ -n "${settings_backup:-}" ] && eagle_dim "  Backup: $settings_backup"
 else
     eagle_warn "Could not patch settings.json (jq not found or file missing)"
 fi
 
+codex_hooks_backup=""
+if [ -f "$EAGLE_CODEX_HOOKS" ]; then
+    codex_hooks_backup=$(eagle_backup_user_file "$EAGLE_CODEX_HOOKS" 2>/dev/null || true)
+fi
 if eagle_remove_codex_hooks; then
     eagle_ok "Hooks removed from Codex hooks.json"
+    [ -n "$codex_hooks_backup" ] && eagle_dim "  Backup: $codex_hooks_backup"
 else
     eagle_warn "Could not patch Codex hooks.json (jq not found or file missing)"
 fi
 
+# ─── Remove instruction blocks and statusline integration ───
+
+claude_md="$HOME/.claude/CLAUDE.md"
+if [ -f "$claude_md" ] && grep -qF "## Eagle Mem — Persistent Memory" "$claude_md" 2>/dev/null; then
+    claude_md_backup=$(eagle_backup_user_file "$claude_md" 2>/dev/null || true)
+    if eagle_remove_marked_markdown_section "$claude_md"; then
+        eagle_ok "Eagle Mem block removed from Claude CLAUDE.md"
+        [ -n "${claude_md_backup:-}" ] && eagle_dim "  Backup: $claude_md_backup"
+    else
+        eagle_warn "Could not remove Eagle Mem block from Claude CLAUDE.md"
+    fi
+else
+    eagle_info "Claude CLAUDE.md block not present"
+fi
+
+if [ -f "$EAGLE_CODEX_AGENTS_MD" ] && grep -qF "## Eagle Mem — Persistent Memory" "$EAGLE_CODEX_AGENTS_MD" 2>/dev/null; then
+    codex_agents_backup=$(eagle_backup_user_file "$EAGLE_CODEX_AGENTS_MD" 2>/dev/null || true)
+    if eagle_remove_marked_markdown_section "$EAGLE_CODEX_AGENTS_MD"; then
+        eagle_ok "Eagle Mem block removed from Codex AGENTS.md"
+        [ -n "${codex_agents_backup:-}" ] && eagle_dim "  Backup: $codex_agents_backup"
+    else
+        eagle_warn "Could not remove Eagle Mem block from Codex AGENTS.md"
+    fi
+else
+    eagle_info "Codex AGENTS.md block not present"
+fi
+
+if eagle_remove_statusline_integration "$SETTINGS"; then
+    eagle_ok "Eagle Mem statusline integration removed"
+else
+    eagle_info "Statusline integration not present or not auto-removable"
+fi
+
 # ─── Remove skill symlinks ────────────────────────────────
 
 if [ -d "$EAGLE_SKILLS_DIR" ]; then
@@ -50,6 +109,14 @@ if [ -d "$EAGLE_SKILLS_DIR" ]; then
     done
 fi
 
+if [ -d "$EAGLE_CODEX_SKILLS_DIR" ]; then
+    for target in "$EAGLE_CODEX_SKILLS_DIR"/eagle-mem-*; do
+        [ -L "$target" ] || [ -d "$target" ] || continue
+        rm -rf "$target"
+        eagle_ok "Codex skill removed: $(basename "$target")"
+    done
+fi
+
 # ─── Optionally wipe data ─────────────────────────────────
 
 if [ -d "$EAGLE_MEM_DIR" ]; then