eagle-mem 4.9.3 → 4.9.4

package/README.md

@@ -152,6 +152,10 @@ Eagle Mem prevents Claude from repeating past mistakes:
 | `eagle-mem scan` | Scan codebase and generate overview |
 | `eagle-mem index` | Index source files for FTS5 code search |
 
+### v4.9.4 Patch
+
+Project-key hardening for agents that move between folders: hooks now keep a per-session project identity instead of recalculating from every new cwd, and statuslines prefer the stored session project before falling back to folder paths. Install/update also repairs older embedded Eagle Mem statusline blocks so nested-repo projects stop showing `Memories: 0` when the session belongs to the parent workspace.
+
 ### v4.9.3 Patch
 
 Follow-up hardening for the v4.9.2 project-key repair: Claude transcript workspace detection now reads complete early JSONL records instead of a fixed byte slice, so large SessionStart hook context cannot hide the first `cwd`. Metadata-only memory/plan/task repairs also avoid touching FTS-indexed columns, preventing SQLite FTS update triggers from firing during safe project/source rekeys.

package/db/034_safe_feature_rekey_trigger.sql

@@ -0,0 +1,17 @@
+-- Migration 034: Make feature FTS updates safe for project-key repairs.
+--
+-- Project-key repairs update features.project, but the older trigger fired on
+-- every UPDATE and tried to rewrite the FTS5 row even when searchable text did
+-- not change. Restrict it to the indexed columns so metadata-only rekeys are
+-- safe.
+
+DROP TRIGGER IF EXISTS features_au;
+
+CREATE TRIGGER features_au
+AFTER UPDATE OF name, description ON features
+BEGIN
+    INSERT INTO features_fts(features_fts, rowid, name, description)
+    VALUES ('delete', old.id, old.name, old.description);
+    INSERT INTO features_fts(rowid, name, description)
+    VALUES (new.id, new.name, new.description);
+END;

package/lib/common.sh

@@ -210,14 +210,231 @@ eagle_transcript_first_cwd() {
     local transcript_path="${1:-}"
     [ -f "$transcript_path" ] || return 1
 
+    local head_lines
+    head_lines=$(sed -n '1,200p' "$transcript_path" 2>/dev/null || true)
+    [ -n "$head_lines" ] || return 1
+
     local cwd
-    cwd=$(sed -n '1,200p' "$transcript_path" 2>/dev/null \
-        | jq -r 'select((.cwd? // "") != "") | .cwd' 2>/dev/null \
+    cwd=$(printf '%s\n' "$head_lines" \
+        | jq -r '
+            [
+                (.payload? | objects | .workspace? | objects | .project_dir? | strings),
+                (.workspace? | objects | .project_dir? | strings),
+                (.payload? | objects | .workspace? | objects | .current_dir? | strings),
+                (.workspace? | objects | .current_dir? | strings),
+                (.cwd? | strings),
+                (.payload? | objects | .cwd? | strings),
+                (.payload? | objects | .current_dir? | strings)
+            ]
+            | .[0] // empty
+        ' 2>/dev/null \
         | awk 'NF { print; exit }' || true)
+
     [ -n "$cwd" ] || return 1
     printf '%s\n' "$cwd"
 }
 
+eagle_session_project_marker_file() {
+    local session_id="${1:-}"
+    eagle_validate_session_id "$session_id" || return 1
+    mkdir -p "$EAGLE_MEM_DIR/session-projects" 2>/dev/null || return 1
+    printf '%s/session-projects/%s\n' "$EAGLE_MEM_DIR" "$session_id"
+}
+
+eagle_get_session_project_marker() {
+    local marker
+    marker=$(eagle_session_project_marker_file "$1") || return 1
+    [ -s "$marker" ] || return 1
+    awk 'NF { print; exit }' "$marker"
+}
+
+eagle_remember_session_project() {
+    local session_id="${1:-}"
+    local project="${2:-}"
+    local force="${3:-0}"
+    [ -n "$project" ] || return 1
+
+    local marker
+    marker=$(eagle_session_project_marker_file "$session_id") || return 1
+    if [ "$force" = "1" ] || [ ! -s "$marker" ]; then
+        printf '%s\n' "$project" > "$marker" 2>/dev/null || return 1
+    fi
+}
+
+eagle_get_session_project_light() {
+    local session_id="${1:-}"
+    eagle_validate_session_id "$session_id" || return 1
+    command -v sqlite3 >/dev/null 2>&1 || return 1
+    [ -f "$EAGLE_MEM_DB" ] || return 1
+
+    local sid_sql project
+    sid_sql=$(eagle_sql_escape "$session_id")
+    project=$(sqlite3 "$EAGLE_MEM_DB" "SELECT project FROM sessions WHERE id = '$sid_sql' AND project != '' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
+    [ -n "$project" ] || return 1
+    printf '%s\n' "$project"
+}
+
+eagle_project_has_table_row() {
+    local table="${1:-}"
+    local project="${2:-}"
+    [ -n "$table" ] && [ -n "$project" ] || return 1
+    command -v sqlite3 >/dev/null 2>&1 || return 1
+    [ -f "$EAGLE_MEM_DB" ] || return 1
+
+    local project_sql found
+    project_sql=$(eagle_sql_escape "$project")
+    found=$(sqlite3 "$EAGLE_MEM_DB" "SELECT 1 FROM $table WHERE project = '$project_sql' LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
+    [ "$found" = "1" ]
+}
+
+eagle_project_from_existing_ancestor() {
+    local path="${1:-}"
+    [ -n "$path" ] || return 1
+
+    local current key
+    current=$(eagle_normalize_project_path "$path")
+    eagle_is_ephemeral_project_path "$current" && return 1
+
+    while [ -n "$current" ] && [ "$current" != "/" ]; do
+        key=$(eagle_project_key_from_target_dir "$current")
+        if [ -n "$key" ]; then
+            # Prefer ancestors with durable memory/summary content. Session-only
+            # rows can be created by the very folder drift this helper repairs.
+            if eagle_project_has_table_row "agent_memories" "$key" \
+                || eagle_project_has_table_row "summaries" "$key"; then
+                printf '%s\n' "$key"
+                return 0
+            fi
+        fi
+
+        [ "$current" = "$HOME" ] && break
+        current=$(dirname "$current")
+    done
+
+    return 1
+}
+
+eagle_project_from_workspace_path() {
+    if [ -n "${EAGLE_MEM_PROJECT:-}" ]; then
+        printf '%s\n' "$EAGLE_MEM_PROJECT"
+        return 0
+    fi
+
+    local path="${1:-}"
+    [ -n "$path" ] || return 1
+
+    local resolved worktree_project git_root project
+    resolved=$(eagle_normalize_project_path "$path")
+    eagle_is_ephemeral_project_path "$resolved" && return 1
+
+    if worktree_project=$(eagle_project_key_for_worktree_path "$resolved"); then
+        printf '%s\n' "$worktree_project"
+        return 0
+    fi
+
+    git_root=$(git -C "$resolved" rev-parse --show-toplevel 2>/dev/null)
+    if [ -n "$git_root" ]; then
+        project=$(eagle_project_key_from_target_dir "$git_root")
+        [ -n "$project" ] && { printf '%s\n' "$project"; return 0; }
+    fi
+
+    if project=$(eagle_project_from_existing_ancestor "$path"); then
+        printf '%s\n' "$project"
+        return 0
+    fi
+
+    project=$(eagle_project_from_path_no_git "$path")
+    [ -n "$project" ] || return 1
+    printf '%s\n' "$project"
+}
+
+eagle_project_from_transcript_start() {
+    local transcript_path="${1:-}"
+    local cwd="${2:-}"
+    [ -f "$transcript_path" ] || return 1
+
+    local transcript_cwd project
+    if project=$(eagle_project_from_claude_transcript "$transcript_path" "$cwd"); then
+        printf '%s\n' "$project"
+        return 0
+    fi
+
+    transcript_cwd=$(eagle_transcript_first_cwd "$transcript_path") || return 1
+    if [ -n "$cwd" ] && ! eagle_path_is_same_or_child "$transcript_cwd" "$cwd"; then
+        return 1
+    fi
+
+    project=$(eagle_project_from_workspace_path "$transcript_cwd")
+    [ -n "$project" ] || return 1
+    printf '%s\n' "$project"
+}
+
+eagle_project_from_statusline_input() {
+    local input="${1:-}"
+    local project_dir="${2:-}"
+    local cwd="${3:-}"
+    local session_id="${4:-}"
+    local project workspace_project_dir transcript_path
+
+    if [ -n "${EAGLE_MEM_PROJECT:-}" ]; then
+        printf '%s\n' "$EAGLE_MEM_PROJECT"
+        return
+    fi
+
+    if [ -z "$session_id" ] && [ -n "$input" ]; then
+        session_id=$(printf '%s' "$input" | jq -r '.session_id // .session.id // empty' 2>/dev/null)
+    fi
+
+    if [ -n "$input" ]; then
+        workspace_project_dir=$(printf '%s' "$input" | jq -r '.workspace.project_dir // empty' 2>/dev/null)
+        transcript_path=$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)
+        [ -z "$cwd" ] && cwd=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
+    fi
+
+    # Explicit workspace project and transcript start are stronger than older
+    # cached session rows because they repair pre-fix sessions that were stored
+    # under a nested folder key.
+    if [ -n "$workspace_project_dir" ]; then
+        project=$(eagle_project_from_workspace_path "$workspace_project_dir")
+        [ -n "$project" ] && { printf '%s\n' "$project"; return; }
+    fi
+
+    if [ -n "$transcript_path" ]; then
+        if project=$(eagle_project_from_transcript_start "$transcript_path" "${cwd:-$project_dir}"); then
+            printf '%s\n' "$project"
+            return
+        fi
+    fi
+
+    if [ -n "$session_id" ]; then
+        if project=$(eagle_get_session_project_light "$session_id"); then
+            printf '%s\n' "$project"
+            return
+        fi
+        if project=$(eagle_get_session_project_marker "$session_id"); then
+            printf '%s\n' "$project"
+            return
+        fi
+    fi
+
+    if [ -z "$project_dir" ] && [ -n "$input" ]; then
+        project_dir=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
+    fi
+    if [ -n "$project_dir" ]; then
+        project=$(eagle_project_from_workspace_path "$project_dir")
+        [ -n "$project" ] && { printf '%s\n' "$project"; return; }
+    fi
+
+    if [ -z "$cwd" ] && [ -n "$input" ]; then
+        cwd=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
+    fi
+    if [ -n "$cwd" ]; then
+        project=$(eagle_project_from_workspace_path "$cwd")
+        [ -n "$project" ] && { printf '%s\n' "$project"; return; }
+    fi
+    eagle_project_from_cwd "$cwd"
+}
+
 eagle_project_from_claude_project_dir() {
     local project_dir="${1:-}"
     project_dir="${project_dir%/}"
@@ -228,7 +445,7 @@ eagle_project_from_claude_project_dir() {
         [ -f "$jsonl" ] || continue
         cwd=$(eagle_transcript_first_cwd "$jsonl")
         [ -z "$cwd" ] && continue
-        project=$(eagle_project_from_path_no_git "$cwd")
+        project=$(eagle_project_from_workspace_path "$cwd")
         [ -n "$project" ] && { printf '%s\n' "$project"; return 0; }
     done
 
@@ -252,7 +469,7 @@ eagle_project_from_claude_transcript() {
         return 1
     fi
 
-    project=$(eagle_project_from_path_no_git "$transcript_cwd")
+    project=$(eagle_project_from_workspace_path "$transcript_cwd")
     [ -n "$project" ] || return 1
     printf '%s\n' "$project"
 }
@@ -265,16 +482,54 @@ eagle_project_from_hook_input() {
         return
     fi
 
-    local cwd transcript_path project
+    local session_id cwd transcript_path workspace_project project
+    session_id=$(printf '%s' "$input" | jq -r '.session_id // empty' 2>/dev/null)
     cwd=$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)
     transcript_path=$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)
 
+    workspace_project=$(printf '%s' "$input" | jq -r '.workspace.project_dir // empty' 2>/dev/null)
+    if [ -n "$workspace_project" ]; then
+        project=$(eagle_project_from_workspace_path "$workspace_project")
+        if [ -n "$project" ]; then
+            [ -n "$session_id" ] && eagle_remember_session_project "$session_id" "$project" 1 >/dev/null 2>&1
+            printf '%s\n' "$project"
+            return
+        fi
+    fi
+
     if project=$(eagle_project_from_claude_transcript "$transcript_path" "$cwd"); then
+        [ -n "$session_id" ] && eagle_remember_session_project "$session_id" "$project" 1 >/dev/null 2>&1
         printf '%s\n' "$project"
         return
     fi
 
-    eagle_project_from_cwd "$cwd"
+    if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
+        local transcript_cwd
+        transcript_cwd=$(eagle_transcript_first_cwd "$transcript_path")
+        if [ -n "$transcript_cwd" ]; then
+            project=$(eagle_project_from_workspace_path "$transcript_cwd")
+            if [ -n "$project" ]; then
+                [ -n "$session_id" ] && eagle_remember_session_project "$session_id" "$project" 1 >/dev/null 2>&1
+                printf '%s\n' "$project"
+                return
+            fi
+        fi
+    fi
+
+    if [ -n "$session_id" ]; then
+        if project=$(eagle_get_session_project_light "$session_id"); then
+            printf '%s\n' "$project"
+            return
+        fi
+        if project=$(eagle_get_session_project_marker "$session_id"); then
+            printf '%s\n' "$project"
+            return
+        fi
+    fi
+
+    project=$(eagle_project_from_cwd "$cwd")
+    [ -n "$session_id" ] && [ -n "$project" ] && eagle_remember_session_project "$session_id" "$project" 0 >/dev/null 2>&1
+    printf '%s\n' "$project"
 }
 
 eagle_project_file_path() {
@@ -810,6 +1065,114 @@ eagle_collect_files() {
     fi
 }
 
+eagle_statusline_script_from_command() {
+    local cmd="${1:-}"
+    [ -z "$cmd" ] && return 1
+
+    cmd="${cmd#sh }"
+    cmd="${cmd#bash }"
+    cmd="${cmd#/bin/sh }"
+    cmd="${cmd#/bin/bash }"
+    cmd="${cmd#zsh }"
+    cmd="${cmd#/bin/zsh }"
+    cmd="${cmd%\"}"
+    cmd="${cmd#\"}"
+    cmd="${cmd%\'}"
+    cmd="${cmd#\'}"
+
+    case "$cmd" in
+        "~/"*) cmd="$HOME/${cmd#\~/}" ;;
+        "\$HOME/"*) cmd="$HOME/${cmd#\$HOME/}" ;;
+        "\${HOME}/"*) cmd="$HOME/${cmd#\$\{HOME\}/}" ;;
+    esac
+
+    if [ -L "$cmd" ]; then
+        local link_target link_dir
+        link_target=$(readlink "$cmd" 2>/dev/null || true)
+        if [ -n "$link_target" ]; then
+            case "$link_target" in
+                /*) cmd="$link_target" ;;
+                *)
+                    link_dir=$(cd "$(dirname "$cmd")" && pwd -P) || return 1
+                    cmd="$link_dir/$link_target"
+                    ;;
+            esac
+        fi
+    fi
+
+    [ -f "$cmd" ] || return 1
+    printf '%s\n' "$cmd"
+}
+
+eagle_statusline_script_uses_input() {
+    local sl_file="${1:-}"
+    [ -f "$sl_file" ] || return 1
+    grep -Eq 'eagle_project_from_statusline_input|eagle_mem_statusline.*(\$\{input:-\}|\$input)' "$sl_file"
+}
+
+eagle_patch_statusline_script() {
+    local sl_file="${1:-}"
+    [ -f "$sl_file" ] || return 1
+    command -v perl >/dev/null 2>&1 || return 1
+
+    if [ -L "$sl_file" ]; then
+        local link_target link_dir
+        link_target=$(readlink "$sl_file" 2>/dev/null || true)
+        if [ -n "$link_target" ]; then
+            case "$link_target" in
+                /*) sl_file="$link_target" ;;
+                *)
+                    link_dir=$(cd "$(dirname "$sl_file")" && pwd -P) || return 1
+                    sl_file="$link_dir/$link_target"
+                    ;;
+            esac
+        fi
+    fi
+
+    local tmp backup mode
+    tmp=$(mktemp) || return 1
+    cp "$sl_file" "$tmp" || { rm -f "$tmp"; return 1; }
+
+    if ! grep -Eq 'eagle_mem_statusline|eagle_project_from_cwd|claude_memories|agent_memories|\.eagle-mem/scripts/statusline-em' "$tmp" 2>/dev/null; then
+        rm -f "$tmp"
+        return 1
+    fi
+
+    perl -0pi -e '
+        s/(project_dir=\$\(echo "\$input" \| jq -r \x27)\.workspace\.current_dir \/\/ \.cwd/$1.workspace.project_dir \/\/ .workspace.current_dir \/\/ .cwd/g;
+        s/(project_dir=\$\(echo "\$input" \| jq -r ")\.workspace\.current_dir \/\/ \.cwd/$1.workspace.project_dir \/\/ .workspace.current_dir \/\/ .cwd/g;
+        s/eagle_mem_statusline "\$project_dir" "\$session_id" "\$\{input\}"/eagle_mem_statusline "\$project_dir" "\$session_id" "\${input:-}"/g;
+        s/eagle_mem_statusline "\$project_dir" "\$session_id"(?=[\)\n;])/eagle_mem_statusline "\$project_dir" "\$session_id" "\${input:-}"/g;
+        s/eagle_mem_statusline "\$project_dir"(?=[\)\n;])/eagle_mem_statusline "\$project_dir" "\${session_id:-}" "\${input:-}"/g;
+        s/eagle_project_from_cwd "\$cwd"/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd "\$project_dir"/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd "\${project_dir:-\$cwd}"/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd "\${project_dir:-\$(pwd)}"/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd "\${eagle_mem_project_dir:-\${project_dir:-\$cwd}}"/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd\("\$cwd"\)/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd\("\$project_dir"\)/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd\("\${project_dir:-\$cwd}"\)/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd\("\${project_dir:-\$(pwd)}"\)/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/eagle_project_from_cwd\("\${eagle_mem_project_dir:-\${project_dir:-\$cwd}}"\)/eagle_project_from_statusline_input "\${input:-}" "\${project_dir:-}" "\${cwd:-}" "\${session_id:-}"/g;
+        s/FROM claude_memories WHERE project/FROM agent_memories WHERE project/g;
+    ' "$tmp" || { rm -f "$tmp"; return 1; }
+
+    if cmp -s "$sl_file" "$tmp"; then
+        rm -f "$tmp"
+        return 1
+    fi
+
+    backup="${sl_file}.eagle-mem.bak-$(date -u +%Y%m%dT%H%M%SZ)"
+    cp "$sl_file" "$backup" 2>/dev/null || true
+    mode=$(stat -f %Lp "$sl_file" 2>/dev/null || stat -c %a "$sl_file" 2>/dev/null || echo "")
+    if ! mv "$tmp" "$sl_file"; then
+        rm -f "$tmp"
+        return 1
+    fi
+    [ -n "$mode" ] && chmod "$mode" "$sl_file" 2>/dev/null || chmod +x "$sl_file" 2>/dev/null || true
+    return 0
+}
+
 _eagle_claude_md_section() {
     cat << 'EAGLE_MD'
 

package/lib/db-sessions.sh

@@ -6,12 +6,16 @@
 _EAGLE_DB_SESSIONS_LOADED=1
 
 eagle_upsert_session() {
-    local session_id; session_id=$(eagle_sql_escape "$1")
-    local project; project=$(eagle_sql_escape "$2")
+    local session_id_raw="${1:-}"
+    local project_raw="${2:-}"
+    local session_id; session_id=$(eagle_sql_escape "$session_id_raw")
+    local project; project=$(eagle_sql_escape "$project_raw")
     local cwd; cwd=$(eagle_sql_escape "${3:-}")
     local model; model=$(eagle_sql_escape "${4:-}")
     local source; source=$(eagle_sql_escape "${5:-}")
     local agent; agent=$(eagle_sql_escape "${6:-$(eagle_agent_source)}")
+    local prior_project
+    prior_project=$(eagle_db "SELECT project FROM sessions WHERE id = '$session_id' LIMIT 1;" 2>/dev/null || true)
 
     eagle_db "INSERT INTO sessions (id, project, cwd, model, source, agent, last_activity_at)
               VALUES ('$session_id', '$project', '$cwd', '$model', '$source', '$agent', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
@@ -22,6 +26,127 @@ eagle_upsert_session() {
                   agent = COALESCE(NULLIF(excluded.agent, ''), sessions.agent),
                   status = 'active',
                   last_activity_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
+
+    local needs_project_repair=0
+    if [ -n "$project_raw" ]; then
+        if [ "$prior_project" != "$project_raw" ]; then
+            needs_project_repair=1
+        else
+            local stale_child
+            stale_child=$(eagle_db "SELECT 1 WHERE
+                EXISTS (SELECT 1 FROM summaries WHERE session_id = '$session_id' AND project != '$project')
+                OR EXISTS (SELECT 1 FROM observations WHERE session_id = '$session_id' AND project != '$project')
+                OR EXISTS (SELECT 1 FROM agent_tasks WHERE source_session_id = '$session_id' AND project != '$project')
+                OR EXISTS (SELECT 1 FROM agent_memories WHERE origin_session_id = '$session_id' AND project != '$project')
+                OR EXISTS (SELECT 1 FROM agent_plans WHERE origin_session_id = '$session_id' AND project != '$project')
+                OR EXISTS (SELECT 1 FROM pending_feature_verifications WHERE source_session_id = '$session_id' AND project != '$project')
+                OR EXISTS (
+                    SELECT 1
+                    FROM pending_feature_verifications p
+                    JOIN features f ON f.id = p.feature_id
+                    WHERE p.source_session_id = '$session_id'
+                      AND f.project != '$project'
+                )
+                LIMIT 1;" 2>/dev/null || true)
+            [ "$stale_child" = "1" ] && needs_project_repair=1
+        fi
+    fi
+
+    if [ "$needs_project_repair" = "1" ]; then
+        eagle_db_pipe <<SQL >/dev/null 2>&1
+BEGIN;
+UPDATE summaries SET project = '$project' WHERE session_id = '$session_id' AND project != '$project';
+UPDATE observations SET project = '$project' WHERE session_id = '$session_id' AND project != '$project';
+UPDATE agent_tasks SET project = '$project' WHERE source_session_id = '$session_id' AND project != '$project';
+UPDATE agent_memories SET project = '$project' WHERE origin_session_id = '$session_id' AND project != '$project';
+UPDATE agent_plans SET project = '$project' WHERE origin_session_id = '$session_id' AND project != '$project';
+CREATE TEMP TABLE IF NOT EXISTS eagle_feature_repair_map (
+    old_feature_id INTEGER PRIMARY KEY,
+    new_feature_id INTEGER NOT NULL
+);
+DELETE FROM eagle_feature_repair_map;
+INSERT OR IGNORE INTO features (project, name, description, status, last_verified_at, last_verified_notes)
+SELECT '$project', f_old.name, f_old.description, f_old.status, f_old.last_verified_at, f_old.last_verified_notes
+FROM pending_feature_verifications p
+JOIN features f_old ON f_old.id = p.feature_id
+WHERE p.source_session_id = '$session_id'
+  AND (p.project != '$project' OR f_old.project != '$project')
+GROUP BY f_old.name;
+INSERT OR REPLACE INTO eagle_feature_repair_map (old_feature_id, new_feature_id)
+SELECT DISTINCT f_old.id, f_new.id
+FROM pending_feature_verifications p
+JOIN features f_old ON f_old.id = p.feature_id
+JOIN features f_new ON f_new.project = '$project' AND f_new.name = f_old.name
+WHERE p.source_session_id = '$session_id'
+  AND (p.project != '$project' OR f_old.project != '$project');
+INSERT OR IGNORE INTO feature_files (feature_id, file_path, role)
+SELECT f_new.id, ff.file_path, ff.role
+FROM pending_feature_verifications p
+JOIN features f_old ON f_old.id = p.feature_id
+JOIN eagle_feature_repair_map m ON m.old_feature_id = f_old.id
+JOIN features f_new ON f_new.id = m.new_feature_id
+JOIN feature_files ff ON ff.feature_id = f_old.id
+WHERE p.source_session_id = '$session_id'
+  AND (p.project != '$project' OR f_old.project != '$project');
+INSERT OR IGNORE INTO feature_dependencies (feature_id, kind, target, name, notes)
+SELECT f_new.id, fd.kind, fd.target, fd.name, fd.notes
+FROM pending_feature_verifications p
+JOIN features f_old ON f_old.id = p.feature_id
+JOIN eagle_feature_repair_map m ON m.old_feature_id = f_old.id
+JOIN features f_new ON f_new.id = m.new_feature_id
+JOIN feature_dependencies fd ON fd.feature_id = f_old.id
+WHERE p.source_session_id = '$session_id'
+  AND (p.project != '$project' OR f_old.project != '$project');
+INSERT OR IGNORE INTO feature_smoke_tests (feature_id, command, description)
+SELECT f_new.id, fst.command, fst.description
+FROM pending_feature_verifications p
+JOIN features f_old ON f_old.id = p.feature_id
+JOIN eagle_feature_repair_map m ON m.old_feature_id = f_old.id
+JOIN features f_new ON f_new.id = m.new_feature_id
+JOIN feature_smoke_tests fst ON fst.feature_id = f_old.id
+WHERE p.source_session_id = '$session_id'
+  AND (p.project != '$project' OR f_old.project != '$project');
+DELETE FROM pending_feature_verifications
+WHERE source_session_id = '$session_id'
+  AND status = 'pending'
+  AND id NOT IN (
+      SELECT MIN(p.id)
+      FROM pending_feature_verifications p
+      LEFT JOIN eagle_feature_repair_map m ON m.old_feature_id = p.feature_id
+      WHERE p.source_session_id = '$session_id'
+        AND p.status = 'pending'
+      GROUP BY
+          CASE WHEN m.new_feature_id IS NOT NULL THEN '$project' ELSE p.project END,
+          COALESCE(m.new_feature_id, p.feature_id),
+          p.file_path
+  )
+  AND EXISTS (
+      SELECT 1
+      FROM eagle_feature_repair_map m
+      WHERE m.old_feature_id = pending_feature_verifications.feature_id
+  );
+UPDATE pending_feature_verifications
+SET feature_id = COALESCE((SELECT new_feature_id FROM eagle_feature_repair_map WHERE old_feature_id = feature_id), feature_id)
+WHERE source_session_id = '$session_id'
+  AND EXISTS (SELECT 1 FROM eagle_feature_repair_map WHERE old_feature_id = pending_feature_verifications.feature_id);
+DELETE FROM pending_feature_verifications
+WHERE source_session_id = '$session_id'
+  AND project != '$project'
+  AND status = 'pending'
+  AND EXISTS (
+      SELECT 1
+      FROM pending_feature_verifications p2
+      WHERE p2.project = '$project'
+        AND p2.feature_id = pending_feature_verifications.feature_id
+        AND p2.file_path = pending_feature_verifications.file_path
+        AND p2.status = 'pending'
+        AND p2.id != pending_feature_verifications.id
+  );
+UPDATE pending_feature_verifications SET project = '$project' WHERE source_session_id = '$session_id' AND project != '$project';
+UPDATE sessions SET project = '$project' WHERE id = '$session_id' AND project != '$project';
+COMMIT;
+SQL
+    fi
 }
 
 eagle_end_session() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "4.9.3",
+  "version": "4.9.4",
   "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code and Codex",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/install.sh

@@ -299,6 +299,7 @@ fi
 if [ "$claude_found" = true ]; then
     EM_STATUSLINE="$EAGLE_MEM_DIR/scripts/statusline-em.sh"
     existing_sl=$(jq -r '.statusLine.command // empty' "$SETTINGS" 2>/dev/null)
+    existing_sl_file=$(eagle_statusline_script_from_command "$existing_sl" 2>/dev/null || true)
 
     if [ -z "$existing_sl" ]; then
         # No statusline configured — set up a minimal one that shows Eagle Mem
@@ -309,29 +310,37 @@ input=$(cat)
 project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""' 2>/dev/null)
 session_id=$(echo "$input" | jq -r '.session_id // .session.id // ""' 2>/dev/null)
 source "$HOME/.eagle-mem/scripts/statusline-em.sh"
-eagle_mem_statusline "$project_dir" "$session_id"
+eagle_mem_statusline "$project_dir" "$session_id" "$input"
 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 "    if [ -f \"\$HOME/.eagle-mem/scripts/statusline-em.sh\" ]; then"
-            eagle_dim "      source \"\$HOME/.eagle-mem/scripts/statusline-em.sh\""
-            eagle_dim "      em_section=\$(eagle_mem_statusline \"\$project_dir\" \"\$session_id\")"
-            eagle_dim "    fi"
-            echo ""
-            eagle_ok "Statusline ${DIM}(manual patch needed — instructions above)${RESET}"
+        # Existing statusline — if it points at a shell script, inspect the
+        # target file. Custom HUD commands often do not include "eagle-mem" in
+        # the command string even when the script contains an embedded block.
+        sl_file="$existing_sl_file"
+        if [ -n "$sl_file" ] && [ -f "$sl_file" ]; then
+            if eagle_patch_statusline_script "$sl_file"; then
+                eagle_ok "Statusline ${DIM}(patched existing Eagle Mem block)${RESET}"
+            elif eagle_statusline_script_uses_input "$sl_file"; then
+                eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
+            else
+                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 "    if [ -f \"\$HOME/.eagle-mem/scripts/statusline-em.sh\" ]; then"
+                eagle_dim "      source \"\$HOME/.eagle-mem/scripts/statusline-em.sh\""
+                eagle_dim "      em_section=\$(eagle_mem_statusline \"\$project_dir\" \"\$session_id\" \"\$input\")"
+                eagle_dim "    fi"
+                echo ""
+                eagle_ok "Statusline ${DIM}(manual patch needed — instructions above)${RESET}"
+            fi
+        elif echo "$existing_sl" | grep -q "eagle-mem"; then
+            eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
         else
             eagle_ok "Statusline ${DIM}(existing — cannot auto-patch; add Eagle Mem manually)${RESET}"
         fi

package/scripts/statusline-em.sh

@@ -6,6 +6,7 @@
 eagle_mem_statusline() {
     local project_dir="${1:-}"
     local session_id="${2:-}"
+    local statusline_input="${3:-}"
     local em_db="$HOME/.eagle-mem/memory.db"
     [ -f "$em_db" ] || return
 
@@ -14,7 +15,7 @@ eagle_mem_statusline() {
 
     local proj
     [ -z "$project_dir" ] && project_dir="$(pwd)"
-    proj=$(eagle_project_from_cwd "$project_dir")
+    proj=$(eagle_project_from_statusline_input "$statusline_input" "$project_dir" "$project_dir" "$session_id")
     [ -z "$proj" ] && return
 
     proj=$(eagle_sql_escape "$proj")
@@ -57,5 +58,5 @@ if [ "${BASH_SOURCE[0]}" = "$0" ]; then
     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"
+    eagle_mem_statusline "${project_dir:-$(pwd)}" "$session_id" "$input"
 fi

package/scripts/update.sh

@@ -153,12 +153,22 @@ input=$(cat)
 project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""' 2>/dev/null)
 session_id=$(echo "$input" | jq -r '.session_id // .session.id // ""' 2>/dev/null)
 source "$HOME/.eagle-mem/scripts/statusline-em.sh"
-eagle_mem_statusline "$project_dir" "$session_id"
+eagle_mem_statusline "$project_dir" "$session_id" "$input"
 WRAPPER
     chmod +x "$statusline_wrapper"
     eagle_ok "Statusline wrapper updated"
 fi
 
+if [ "$claude_found" = true ] && [ -f "$SETTINGS" ] && command -v jq >/dev/null 2>&1; then
+    existing_sl=$(jq -r '.statusLine.command // empty' "$SETTINGS" 2>/dev/null)
+    existing_sl_file=$(eagle_statusline_script_from_command "$existing_sl" 2>/dev/null || true)
+    if eagle_patch_statusline_script "$existing_sl_file"; then
+        eagle_ok "Statusline custom Eagle Mem block patched"
+    elif [ -n "$existing_sl_file" ] && [ -f "$existing_sl_file" ] && grep -q "eagle-mem" "$existing_sl_file" && ! eagle_statusline_script_uses_input "$existing_sl_file"; then
+        eagle_warn "Statusline custom Eagle Mem block needs manual input-aware update"
+    fi
+fi
+
 # ─── Backfill project names ───────────────────────────────
 
 backfilled=$(eagle_backfill_projects 2>/dev/null)