eagle-mem 4.9.2 → 4.9.4

package/README.md

@@ -152,6 +152,14 @@ 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.
+
 ### v4.9.2 Patch
 
 Nested-repo Claude Code projects now use one stable project key. When a Claude workspace contains a git repo subdirectory, hooks prefer the Claude transcript workspace root while repo-local CLI commands can still use git-root keys where appropriate. Memory sync and backfill also repair unchanged memory rows whose content hash stayed the same but whose project key was stale. FTS5 update triggers now ignore metadata-only project rekeys, avoiding SQLite virtual-table errors during safe repairs.

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,15 +210,229 @@ eagle_transcript_first_cwd() {
     local transcript_path="${1:-}"
     [ -f "$transcript_path" ] || return 1
 
-    local sample
-    sample=$(dd if="$transcript_path" bs=65536 count=4 2>/dev/null)
-    [ -n "$sample" ] || 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=$(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
 
-    printf '%s\n' "$sample" | sed -nE '/"cwd"[[:space:]]*:/ {
-        s/.*"cwd"[[:space:]]*:[[:space:]]*"([^"]*)".*/\1/
-        p
-        q
-    }'
+    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() {
@@ -231,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
 
@@ -255,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"
 }
@@ -268,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() {
@@ -813,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-mirrors.sh

@@ -63,22 +63,32 @@ eagle_capture_agent_memory() {
     agent_sql=$(eagle_sql_escape "$agent")
 
     eagle_db_pipe <<SQL
-INSERT INTO agent_memories (project, file_path, memory_name, description, memory_type, content, content_hash, origin_session_id, origin_agent)
-VALUES ('$proj_sql', '$fp_sql', '$name_sql', '$desc_sql', '$type_sql', '$content_sql', '$hash_sql', '$origin_sql', '$agent_sql')
-ON CONFLICT(file_path) DO UPDATE SET
-    memory_name     = excluded.memory_name,
-    description     = excluded.description,
-    memory_type     = excluded.memory_type,
-    content         = excluded.content,
-    content_hash    = excluded.content_hash,
-    origin_session_id = COALESCE(NULLIF(excluded.origin_session_id, ''), agent_memories.origin_session_id),
-    origin_agent    = COALESCE(NULLIF(excluded.origin_agent, ''), agent_memories.origin_agent),
-    project         = CASE WHEN excluded.project != '' THEN excluded.project ELSE agent_memories.project END,
-    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
-WHERE agent_memories.content_hash != excluded.content_hash
-   OR (excluded.project != '' AND agent_memories.project != excluded.project)
-   OR (excluded.origin_session_id != '' AND agent_memories.origin_session_id != excluded.origin_session_id)
-   OR (excluded.origin_agent != '' AND agent_memories.origin_agent != excluded.origin_agent);
+INSERT OR IGNORE INTO agent_memories (project, file_path, memory_name, description, memory_type, content, content_hash, origin_session_id, origin_agent)
+VALUES ('$proj_sql', '$fp_sql', '$name_sql', '$desc_sql', '$type_sql', '$content_sql', '$hash_sql', '$origin_sql', '$agent_sql');
+
+UPDATE agent_memories
+SET memory_name       = '$name_sql',
+    description       = '$desc_sql',
+    memory_type       = '$type_sql',
+    content           = '$content_sql',
+    content_hash      = '$hash_sql',
+    origin_session_id = COALESCE(NULLIF('$origin_sql', ''), origin_session_id),
+    origin_agent      = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    project           = CASE WHEN '$proj_sql' != '' THEN '$proj_sql' ELSE project END,
+    updated_at        = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql'
+  AND content_hash != '$hash_sql';
+
+UPDATE agent_memories
+SET origin_session_id = COALESCE(NULLIF('$origin_sql', ''), origin_session_id),
+    origin_agent      = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    project           = CASE WHEN '$proj_sql' != '' THEN '$proj_sql' ELSE project END,
+    updated_at        = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql'
+  AND content_hash = '$hash_sql'
+  AND (('$proj_sql' != '' AND project != '$proj_sql')
+       OR ('$origin_sql' != '' AND origin_session_id != '$origin_sql')
+       OR ('$agent_sql' != '' AND origin_agent != '$agent_sql'));
 SQL
 }
 
@@ -151,20 +161,30 @@ eagle_capture_agent_plan() {
     agent_sql=$(eagle_sql_escape "$agent")
 
     eagle_db_pipe <<SQL
-INSERT INTO agent_plans (project, file_path, title, content, content_hash, origin_session_id, origin_agent)
-VALUES ('$proj_sql', '$fp_sql', '$title_sql', '$content_sql', '$hash_sql', '$origin_sql', '$agent_sql')
-ON CONFLICT(file_path) DO UPDATE SET
-    title           = excluded.title,
-    content         = excluded.content,
-    content_hash    = excluded.content_hash,
-    origin_session_id = COALESCE(NULLIF(excluded.origin_session_id, ''), agent_plans.origin_session_id),
-    origin_agent    = COALESCE(NULLIF(excluded.origin_agent, ''), agent_plans.origin_agent),
-    project         = CASE WHEN excluded.project != '' THEN excluded.project ELSE agent_plans.project END,
-    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
-WHERE agent_plans.content_hash != excluded.content_hash
-   OR (excluded.project != '' AND agent_plans.project != excluded.project)
-   OR (excluded.origin_session_id != '' AND agent_plans.origin_session_id != excluded.origin_session_id)
-   OR (excluded.origin_agent != '' AND agent_plans.origin_agent != excluded.origin_agent);
+INSERT OR IGNORE INTO agent_plans (project, file_path, title, content, content_hash, origin_session_id, origin_agent)
+VALUES ('$proj_sql', '$fp_sql', '$title_sql', '$content_sql', '$hash_sql', '$origin_sql', '$agent_sql');
+
+UPDATE agent_plans
+SET title             = '$title_sql',
+    content           = '$content_sql',
+    content_hash      = '$hash_sql',
+    origin_session_id = COALESCE(NULLIF('$origin_sql', ''), origin_session_id),
+    origin_agent      = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    project           = CASE WHEN '$proj_sql' != '' THEN '$proj_sql' ELSE project END,
+    updated_at        = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql'
+  AND content_hash != '$hash_sql';
+
+UPDATE agent_plans
+SET origin_session_id = COALESCE(NULLIF('$origin_sql', ''), origin_session_id),
+    origin_agent      = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    project           = CASE WHEN '$proj_sql' != '' THEN '$proj_sql' ELSE project END,
+    updated_at        = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql'
+  AND content_hash = '$hash_sql'
+  AND (('$proj_sql' != '' AND project != '$proj_sql')
+       OR ('$origin_sql' != '' AND origin_session_id != '$origin_sql')
+       OR ('$agent_sql' != '' AND origin_agent != '$agent_sql'));
 SQL
 }
 
@@ -252,22 +272,31 @@ eagle_capture_agent_task() {
     agent_sql=$(eagle_sql_escape "$agent")
 
     eagle_db_pipe <<SQL
-INSERT INTO agent_tasks (project, source_session_id, source_task_id, file_path, subject, description, active_form, status, blocks, blocked_by, content_hash, origin_agent)
-VALUES ('$proj_sql', '$sid_sql', '$tid_sql', '$fp_sql', '$subj_sql', '$desc_sql', '$af_sql', '$status_sql', '$blocks_sql', '$bb_sql', '$hash_sql', '$agent_sql')
-ON CONFLICT(file_path) DO UPDATE SET
-    subject         = excluded.subject,
-    description     = excluded.description,
-    active_form     = excluded.active_form,
-    status          = excluded.status,
-    blocks          = excluded.blocks,
-    blocked_by      = excluded.blocked_by,
-    content_hash    = excluded.content_hash,
-    origin_agent    = excluded.origin_agent,
-    project         = CASE WHEN excluded.project != '' THEN excluded.project ELSE agent_tasks.project END,
-    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
-WHERE agent_tasks.content_hash != excluded.content_hash
-   OR (excluded.project != '' AND agent_tasks.project != excluded.project)
-   OR (excluded.origin_agent != '' AND agent_tasks.origin_agent != excluded.origin_agent);
+INSERT OR IGNORE INTO agent_tasks (project, source_session_id, source_task_id, file_path, subject, description, active_form, status, blocks, blocked_by, content_hash, origin_agent)
+VALUES ('$proj_sql', '$sid_sql', '$tid_sql', '$fp_sql', '$subj_sql', '$desc_sql', '$af_sql', '$status_sql', '$blocks_sql', '$bb_sql', '$hash_sql', '$agent_sql');
+
+UPDATE agent_tasks
+SET subject       = '$subj_sql',
+    description   = '$desc_sql',
+    active_form   = '$af_sql',
+    status        = '$status_sql',
+    blocks        = '$blocks_sql',
+    blocked_by    = '$bb_sql',
+    content_hash  = '$hash_sql',
+    origin_agent  = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    project       = CASE WHEN '$proj_sql' != '' THEN '$proj_sql' ELSE project END,
+    updated_at    = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql'
+  AND content_hash != '$hash_sql';
+
+UPDATE agent_tasks
+SET origin_agent  = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    project       = CASE WHEN '$proj_sql' != '' THEN '$proj_sql' ELSE project END,
+    updated_at    = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql'
+  AND content_hash = '$hash_sql'
+  AND (('$proj_sql' != '' AND project != '$proj_sql')
+       OR ('$agent_sql' != '' AND origin_agent != '$agent_sql'));
 SQL
 }
 

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.2",
+  "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)