eagle-mem 4.9.1 → 4.9.3

package/README.md

@@ -152,6 +152,16 @@ 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.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.
+
+Installer parity also improved: first-time install now auto-provisions RTK when Cargo is available, the Eagle Mem statusline shows version/session/memory/turn counts, `eagle-mem statusline` is available as a CLI command, and Codex instructions explicitly call out that Codex currently has hook recall plus the statusline command rather than Claude Code's persistent custom statusline UI.
+
 ### v4.9.1 Patch
 
 `eagle-mem updates status` now refreshes the npm version live, and install/update seed the local latest-version cache with the installed version. This avoids confusing status output immediately after an update.

package/bin/eagle-mem

@@ -23,6 +23,7 @@ case "$command" in
     health)     bash "$SCRIPTS_DIR/health.sh" "$@" ;;
     config)     bash "$SCRIPTS_DIR/config.sh" "$@" ;;
     updates)    bash "$SCRIPTS_DIR/updates.sh" "$@" ;;
+    statusline) "$SCRIPTS_DIR/statusline-em.sh" "$@" ;;
     guard)      bash "$SCRIPTS_DIR/guard.sh" "$@" ;;
     overview)   bash "$SCRIPTS_DIR/overview.sh" "$@" ;;
     session|sessions)

package/db/003_code_chunks.sql

@@ -38,7 +38,9 @@ CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON code_chunks BEGIN
     VALUES ('delete', old.id, old.file_path, old.content);
 END;
 
-CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON code_chunks BEGIN
+CREATE TRIGGER IF NOT EXISTS chunks_au
+AFTER UPDATE OF file_path, content ON code_chunks
+BEGIN
     INSERT INTO code_chunks_fts(code_chunks_fts, rowid, file_path, content)
     VALUES ('delete', old.id, old.file_path, old.content);
     INSERT INTO code_chunks_fts(rowid, file_path, content)

package/db/005_claude_memories.sql

@@ -41,7 +41,9 @@ CREATE TRIGGER IF NOT EXISTS claude_memories_ad AFTER DELETE ON claude_memories
     VALUES ('delete', old.id, old.memory_name, old.description, old.content);
 END;
 
-CREATE TRIGGER IF NOT EXISTS claude_memories_au AFTER UPDATE ON claude_memories BEGIN
+CREATE TRIGGER IF NOT EXISTS claude_memories_au
+AFTER UPDATE OF memory_name, description, content ON claude_memories
+BEGIN
     INSERT INTO claude_memories_fts(claude_memories_fts, rowid, memory_name, description, content)
     VALUES ('delete', old.id, old.memory_name, old.description, old.content);
     INSERT INTO claude_memories_fts(rowid, memory_name, description, content)

package/db/006_claude_plans.sql

@@ -37,7 +37,9 @@ CREATE TRIGGER IF NOT EXISTS claude_plans_ad AFTER DELETE ON claude_plans BEGIN
     VALUES ('delete', old.id, old.title, old.content);
 END;
 
-CREATE TRIGGER IF NOT EXISTS claude_plans_au AFTER UPDATE ON claude_plans BEGIN
+CREATE TRIGGER IF NOT EXISTS claude_plans_au
+AFTER UPDATE OF title, content ON claude_plans
+BEGIN
     INSERT INTO claude_plans_fts(claude_plans_fts, rowid, title, content)
     VALUES ('delete', old.id, old.title, old.content);
     INSERT INTO claude_plans_fts(rowid, title, content)

package/db/007_claude_tasks.sql

@@ -42,7 +42,9 @@ CREATE TRIGGER IF NOT EXISTS claude_tasks_ad AFTER DELETE ON claude_tasks BEGIN
     VALUES ('delete', old.id, old.subject, old.description);
 END;
 
-CREATE TRIGGER IF NOT EXISTS claude_tasks_au AFTER UPDATE ON claude_tasks BEGIN
+CREATE TRIGGER IF NOT EXISTS claude_tasks_au
+AFTER UPDATE OF subject, description ON claude_tasks
+BEGIN
     INSERT INTO claude_tasks_fts(claude_tasks_fts, rowid, subject, description)
     VALUES ('delete', old.id, old.subject, old.description);
     INSERT INTO claude_tasks_fts(rowid, subject, description)

package/db/008_summary_upsert.sql

@@ -49,7 +49,9 @@ CREATE TRIGGER summaries_ad AFTER DELETE ON summaries BEGIN
     VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes);
 END;
 
-CREATE TRIGGER summaries_au AFTER UPDATE ON summaries BEGIN
+CREATE TRIGGER summaries_au
+AFTER UPDATE OF request, investigated, learned, completed, next_steps, notes ON summaries
+BEGIN
     INSERT INTO summaries_fts(summaries_fts, rowid, request, investigated, learned, completed, next_steps, notes)
     VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes);
     INSERT INTO summaries_fts(rowid, request, investigated, learned, completed, next_steps, notes)

package/db/012_enriched_summaries.sql

@@ -43,7 +43,9 @@ CREATE TRIGGER summaries_ad AFTER DELETE ON summaries BEGIN
     VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes, old.decisions, old.gotchas, old.key_files);
 END;
 
-CREATE TRIGGER summaries_au AFTER UPDATE ON summaries BEGIN
+CREATE TRIGGER summaries_au
+AFTER UPDATE OF request, investigated, learned, completed, next_steps, notes, decisions, gotchas, key_files ON summaries
+BEGIN
     INSERT INTO summaries_fts(summaries_fts, rowid, request, investigated, learned, completed, next_steps, notes, decisions, gotchas, key_files)
     VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes, old.decisions, old.gotchas, old.key_files);
     INSERT INTO summaries_fts(rowid, request, investigated, learned, completed, next_steps, notes, decisions, gotchas, key_files)

package/db/028_agent_artifact_tables.sql

@@ -78,7 +78,9 @@ CREATE TRIGGER IF NOT EXISTS agent_memories_ad AFTER DELETE ON agent_memories BE
     VALUES ('delete', old.id, old.memory_name, old.description, old.content);
 END;
 
-CREATE TRIGGER IF NOT EXISTS agent_memories_au AFTER UPDATE ON agent_memories BEGIN
+CREATE TRIGGER IF NOT EXISTS agent_memories_au
+AFTER UPDATE OF memory_name, description, content ON agent_memories
+BEGIN
     INSERT INTO agent_memories_fts(agent_memories_fts, rowid, memory_name, description, content)
     VALUES ('delete', old.id, old.memory_name, old.description, old.content);
     INSERT INTO agent_memories_fts(rowid, memory_name, description, content)
@@ -95,7 +97,9 @@ CREATE TRIGGER IF NOT EXISTS agent_plans_ad AFTER DELETE ON agent_plans BEGIN
     VALUES ('delete', old.id, old.title, old.content);
 END;
 
-CREATE TRIGGER IF NOT EXISTS agent_plans_au AFTER UPDATE ON agent_plans BEGIN
+CREATE TRIGGER IF NOT EXISTS agent_plans_au
+AFTER UPDATE OF title, content ON agent_plans
+BEGIN
     INSERT INTO agent_plans_fts(agent_plans_fts, rowid, title, content)
     VALUES ('delete', old.id, old.title, old.content);
     INSERT INTO agent_plans_fts(rowid, title, content)
@@ -112,7 +116,9 @@ CREATE TRIGGER IF NOT EXISTS agent_tasks_ad AFTER DELETE ON agent_tasks BEGIN
     VALUES ('delete', old.id, old.subject, old.description);
 END;
 
-CREATE TRIGGER IF NOT EXISTS agent_tasks_au AFTER UPDATE ON agent_tasks BEGIN
+CREATE TRIGGER IF NOT EXISTS agent_tasks_au
+AFTER UPDATE OF subject, description ON agent_tasks
+BEGIN
     INSERT INTO agent_tasks_fts(agent_tasks_fts, rowid, subject, description)
     VALUES ('delete', old.id, old.subject, old.description);
     INSERT INTO agent_tasks_fts(rowid, subject, description)

package/db/033_safe_project_rekey_triggers.sql

@@ -0,0 +1,57 @@
+-- Migration 033: Make FTS triggers safe for project-key repairs.
+--
+-- SQLite FTS5 external-content tables can throw unsafe virtual-table errors
+-- when UPDATE triggers try to delete/reinsert FTS rows during metadata-only
+-- repairs. Project rekeys do not change searchable text, so the FTS UPDATE
+-- triggers should only run when indexed columns change.
+
+DROP TRIGGER IF EXISTS summaries_au;
+DROP TRIGGER IF EXISTS chunks_au;
+DROP TRIGGER IF EXISTS agent_memories_au;
+DROP TRIGGER IF EXISTS agent_plans_au;
+DROP TRIGGER IF EXISTS agent_tasks_au;
+
+CREATE TRIGGER summaries_au
+AFTER UPDATE OF request, investigated, learned, completed, next_steps, notes, decisions, gotchas, key_files ON summaries
+BEGIN
+    INSERT INTO summaries_fts(summaries_fts, rowid, request, investigated, learned, completed, next_steps, notes, decisions, gotchas, key_files)
+    VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes, old.decisions, old.gotchas, old.key_files);
+    INSERT INTO summaries_fts(rowid, request, investigated, learned, completed, next_steps, notes, decisions, gotchas, key_files)
+    VALUES (new.id, new.request, new.investigated, new.learned, new.completed, new.next_steps, new.notes, new.decisions, new.gotchas, new.key_files);
+END;
+
+CREATE TRIGGER chunks_au
+AFTER UPDATE OF file_path, content ON code_chunks
+BEGIN
+    INSERT INTO code_chunks_fts(code_chunks_fts, rowid, file_path, content)
+    VALUES ('delete', old.id, old.file_path, old.content);
+    INSERT INTO code_chunks_fts(rowid, file_path, content)
+    VALUES (new.id, new.file_path, new.content);
+END;
+
+CREATE TRIGGER agent_memories_au
+AFTER UPDATE OF memory_name, description, content ON agent_memories
+BEGIN
+    INSERT INTO agent_memories_fts(agent_memories_fts, rowid, memory_name, description, content)
+    VALUES ('delete', old.id, old.memory_name, old.description, old.content);
+    INSERT INTO agent_memories_fts(rowid, memory_name, description, content)
+    VALUES (new.id, new.memory_name, new.description, new.content);
+END;
+
+CREATE TRIGGER agent_plans_au
+AFTER UPDATE OF title, content ON agent_plans
+BEGIN
+    INSERT INTO agent_plans_fts(agent_plans_fts, rowid, title, content)
+    VALUES ('delete', old.id, old.title, old.content);
+    INSERT INTO agent_plans_fts(rowid, title, content)
+    VALUES (new.id, new.title, new.content);
+END;
+
+CREATE TRIGGER agent_tasks_au
+AFTER UPDATE OF subject, description ON agent_tasks
+BEGIN
+    INSERT INTO agent_tasks_fts(agent_tasks_fts, rowid, subject, description)
+    VALUES ('delete', old.id, old.subject, old.description);
+    INSERT INTO agent_tasks_fts(rowid, subject, description)
+    VALUES (new.id, new.subject, new.description);
+END;

package/db/schema.sql

@@ -99,7 +99,9 @@ CREATE TRIGGER IF NOT EXISTS summaries_ad AFTER DELETE ON summaries BEGIN
     VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes);
 END;
 
-CREATE TRIGGER IF NOT EXISTS summaries_au AFTER UPDATE ON summaries BEGIN
+CREATE TRIGGER IF NOT EXISTS summaries_au
+AFTER UPDATE OF request, investigated, learned, completed, next_steps, notes ON summaries
+BEGIN
     INSERT INTO summaries_fts(summaries_fts, rowid, request, investigated, learned, completed, next_steps, notes)
     VALUES ('delete', old.id, old.request, old.investigated, old.learned, old.completed, old.next_steps, old.notes);
     INSERT INTO summaries_fts(rowid, request, investigated, learned, completed, next_steps, notes)

package/hooks/post-tool-use.sh

@@ -30,7 +30,7 @@ if [ -z "$session_id" ]; then exit 0; fi
 case "$hook_event" in
     TaskCreated|TaskCompleted)
         [ ! -f "$EAGLE_MEM_DB" ] && exit 0
-        project=$(eagle_project_from_cwd "$cwd")
+        project=$(eagle_project_from_hook_input "$input")
         [ -z "$project" ] && exit 0
         eagle_upsert_session "$session_id" "$project" "$cwd" "" "" "$agent"
 
@@ -79,7 +79,7 @@ esac
 
 [ ! -f "$EAGLE_MEM_DB" ] && exit 0
 
-project=$(eagle_project_from_cwd "$cwd")
+project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
 
 # Ensure session row exists before inserting observations (FK constraint).

package/hooks/pre-tool-use.sh

@@ -33,7 +33,7 @@ esac
 
 session_id=$(echo "$input" | jq -r '.session_id // empty')
 cwd=$(echo "$input" | jq -r '.cwd // empty')
-project=$(eagle_project_from_cwd "$cwd")
+project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
 
 context=""

package/hooks/session-end.sh

@@ -22,7 +22,7 @@ agent=$(eagle_agent_source_from_json "$input")
 [ ! -f "$EAGLE_MEM_DB" ] && exit 0
 
 cwd=$(echo "$input" | jq -r '.cwd // empty')
-project=$(eagle_project_from_cwd "$cwd")
+project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
 
 # Final sweep: re-capture all task files to catch status changes

package/hooks/session-start.sh

@@ -33,7 +33,7 @@ codex_compact=0
 
 [ -z "$session_id" ] && exit 0
 
-project=$(eagle_project_from_cwd "$cwd")
+project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
 
 p_esc=$(eagle_sql_escape "$project")

package/hooks/stop.sh

@@ -33,7 +33,7 @@ agent=$(eagle_agent_source_from_json "$input")
 agent_type=$(echo "$input" | jq -r '.agent_type // empty')
 [ -n "$agent_type" ] && [ "$agent_type" != "main" ] && exit 0
 
-project=$(eagle_project_from_cwd "$cwd")
+project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
 
 eagle_log "INFO" "Stop: session=$session_id project=$project transcript=$transcript_path agent=$agent"

package/hooks/user-prompt-submit.sh

@@ -25,7 +25,7 @@ agent=$(eagle_agent_source_from_json "$input")
 
 [ -z "$user_prompt" ] && exit 0
 
-project=$(eagle_project_from_cwd "$cwd")
+project=$(eagle_project_from_hook_input "$input")
 codex_compact=0
 [ "$agent" = "codex" ] && codex_compact=1
 

package/lib/common.sh

@@ -8,10 +8,10 @@ EAGLE_MEM_DIR="${EAGLE_MEM_DIR:-$HOME/.eagle-mem}"
 EAGLE_MEM_DB="$EAGLE_MEM_DIR/memory.db"
 EAGLE_MEM_LOG="$EAGLE_MEM_DIR/eagle-mem.log"
 EAGLE_SETTINGS="${EAGLE_SETTINGS:-$HOME/.claude/settings.json}"
-EAGLE_SKILLS_DIR="$HOME/.claude/skills"
-EAGLE_CLAUDE_PROJECTS_DIR="$HOME/.claude/projects"
-EAGLE_CLAUDE_PLANS_DIR="$HOME/.claude/plans"
-EAGLE_CLAUDE_TASKS_DIR="$HOME/.claude/tasks"
+EAGLE_SKILLS_DIR="${EAGLE_SKILLS_DIR:-$HOME/.claude/skills}"
+EAGLE_CLAUDE_PROJECTS_DIR="${EAGLE_CLAUDE_PROJECTS_DIR:-$HOME/.claude/projects}"
+EAGLE_CLAUDE_PLANS_DIR="${EAGLE_CLAUDE_PLANS_DIR:-$HOME/.claude/plans}"
+EAGLE_CLAUDE_TASKS_DIR="${EAGLE_CLAUDE_TASKS_DIR:-$HOME/.claude/tasks}"
 EAGLE_CODEX_DIR="${EAGLE_CODEX_DIR:-$HOME/.codex}"
 EAGLE_CODEX_CONFIG="${EAGLE_CODEX_CONFIG:-$EAGLE_CODEX_DIR/config.toml}"
 EAGLE_CODEX_HOOKS="${EAGLE_CODEX_HOOKS:-$EAGLE_CODEX_DIR/hooks.json}"
@@ -71,30 +71,52 @@ eagle_log() {
     echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [$level] $*" >> "$EAGLE_MEM_LOG" 2>/dev/null || true
 }
 
-eagle_project_from_cwd() {
-    if [ -n "${EAGLE_MEM_PROJECT:-}" ]; then
-        echo "$EAGLE_MEM_PROJECT"
-        return
-    fi
+eagle_normalize_project_path() {
+    local path="${1:-$(pwd)}"
 
-    local cwd="${1:-$(pwd)}"
-    local resolved="$cwd"
+    # Normalize macOS /private prefixes.
+    case "$path" in /private/tmp*) path="/tmp${path#/private/tmp}" ;; esac
+    case "$path" in /private/var/*) path="/var${path#/private/var}" ;; esac
+
+    printf '%s\n' "$path"
+}
 
-    # Normalize macOS /private prefixes
-    case "$resolved" in /private/tmp*) resolved="/tmp${resolved#/private/tmp}" ;; esac
-    case "$resolved" in /private/var/*) resolved="/var${resolved#/private/var}" ;; esac
+eagle_is_ephemeral_project_path() {
+    local path="${1:-}"
 
-    # Skip ephemeral directories — return empty so hooks early-exit
-    case "$resolved" in
-        /tmp|/tmp/*|/var/tmp|/var/tmp/*) echo ""; return ;;
-        /var/folders|/var/folders/*) echo ""; return ;;
-        "$HOME/Downloads"|"$HOME/Downloads/"*) echo ""; return ;;
-        "$HOME/Desktop"|"$HOME/Desktop/"*) echo ""; return ;;
+    case "$path" in
+        /tmp|/tmp/*|/var/tmp|/var/tmp/*) return 0 ;;
+        /var/folders|/var/folders/*) return 0 ;;
+        "$HOME/Downloads"|"$HOME/Downloads/"*) return 0 ;;
+        "$HOME/Desktop"|"$HOME/Desktop/"*) return 0 ;;
     esac
 
-    # Eagle Mem worker lanes run in sibling git worktrees under
-    # <parent>/.eagle-worktrees/<repo>/<lane>. Keep their observations attached
-    # to the real project, not to the disposable worktree path.
+    return 1
+}
+
+eagle_project_key_from_target_dir() {
+    local target_dir="${1:-}"
+    [ -z "$target_dir" ] && return 1
+
+    local name
+    name=$(basename "$target_dir")
+    if [ ${#name} -le 1 ]; then
+        echo ""
+        return 0
+    fi
+
+    if [[ "$target_dir" == "$HOME/"* ]]; then
+        echo "${target_dir#$HOME/}"
+    elif [ "$target_dir" = "$HOME" ]; then
+        echo "$name"
+    else
+        echo "${target_dir#/}"
+    fi
+}
+
+eagle_project_key_for_worktree_path() {
+    local resolved="${1:-}"
+
     case "$resolved" in
         "$HOME"/*/.eagle-worktrees/*)
             local worktree_parent worktree_tail worktree_repo worktree_project
@@ -103,34 +125,156 @@ eagle_project_from_cwd() {
             worktree_repo="${worktree_tail%%/*}"
             worktree_project="$worktree_parent/$worktree_repo"
             if [ -n "$worktree_repo" ] && [ -d "$worktree_project" ]; then
-                echo "${worktree_project#$HOME/}"
-                return
+                eagle_project_key_from_target_dir "$worktree_project"
+                return 0
             fi
             ;;
     esac
 
+    return 1
+}
+
+eagle_project_from_path_no_git() {
+    if [ -n "${EAGLE_MEM_PROJECT:-}" ]; then
+        echo "$EAGLE_MEM_PROJECT"
+        return
+    fi
+
+    local path="${1:-$(pwd)}"
+    local resolved
+    resolved=$(eagle_normalize_project_path "$path")
+
+    if eagle_is_ephemeral_project_path "$resolved"; then
+        echo ""
+        return
+    fi
+
+    local worktree_project
+    if worktree_project=$(eagle_project_key_for_worktree_path "$resolved"); then
+        echo "$worktree_project"
+        return
+    fi
+
+    eagle_project_key_from_target_dir "$resolved"
+}
+
+eagle_project_from_cwd() {
+    if [ -n "${EAGLE_MEM_PROJECT:-}" ]; then
+        echo "$EAGLE_MEM_PROJECT"
+        return
+    fi
+
+    local cwd="${1:-$(pwd)}"
+    local resolved
+    resolved=$(eagle_normalize_project_path "$cwd")
+
+    # Skip ephemeral directories — return empty so hooks early-exit.
+    if eagle_is_ephemeral_project_path "$resolved"; then
+        echo ""
+        return
+    fi
+
+    # Eagle Mem worker lanes run in sibling git worktrees under
+    # <parent>/.eagle-worktrees/<repo>/<lane>. Keep their observations attached
+    # to the real project, not to the disposable worktree path.
+    local worktree_project
+    if worktree_project=$(eagle_project_key_for_worktree_path "$resolved"); then
+        echo "$worktree_project"
+        return
+    fi
+
     local target_dir
     local git_root
-    git_root=$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)
+    git_root=$(git -C "$resolved" rev-parse --show-toplevel 2>/dev/null)
     if [ -n "$git_root" ]; then
         target_dir="$git_root"
     else
-        target_dir="$cwd"
+        target_dir="$resolved"
     fi
 
-    local name
-    name=$(basename "$target_dir")
-    if [ ${#name} -le 1 ]; then
-        echo ""; return
+    eagle_project_key_from_target_dir "$target_dir"
+}
+
+eagle_path_is_same_or_child() {
+    local parent child
+    parent=$(eagle_normalize_project_path "${1:-}")
+    child=$(eagle_normalize_project_path "${2:-}")
+
+    [ -z "$parent" ] || [ -z "$child" ] && return 1
+    [ "$child" = "$parent" ] && return 0
+    case "$child" in "$parent"/*) return 0 ;; esac
+    return 1
+}
+
+eagle_transcript_first_cwd() {
+    local transcript_path="${1:-}"
+    [ -f "$transcript_path" ] || return 1
+
+    local cwd
+    cwd=$(sed -n '1,200p' "$transcript_path" 2>/dev/null \
+        | jq -r 'select((.cwd? // "") != "") | .cwd' 2>/dev/null \
+        | awk 'NF { print; exit }' || true)
+    [ -n "$cwd" ] || return 1
+    printf '%s\n' "$cwd"
+}
+
+eagle_project_from_claude_project_dir() {
+    local project_dir="${1:-}"
+    project_dir="${project_dir%/}"
+    [ -d "$project_dir" ] || return 1
+
+    local jsonl cwd project
+    for jsonl in "$project_dir"/*.jsonl; do
+        [ -f "$jsonl" ] || continue
+        cwd=$(eagle_transcript_first_cwd "$jsonl")
+        [ -z "$cwd" ] && continue
+        project=$(eagle_project_from_path_no_git "$cwd")
+        [ -n "$project" ] && { printf '%s\n' "$project"; return 0; }
+    done
+
+    return 1
+}
+
+eagle_project_from_claude_transcript() {
+    local transcript_path="${1:-}"
+    local cwd="${2:-}"
+
+    case "$transcript_path" in
+        "$EAGLE_CLAUDE_PROJECTS_DIR"/*/*.jsonl) ;;
+        *) return 1 ;;
+    esac
+
+    local transcript_cwd project
+    transcript_cwd=$(eagle_transcript_first_cwd "$transcript_path")
+    [ -n "$transcript_cwd" ] || return 1
+
+    if [ -n "$cwd" ] && ! eagle_path_is_same_or_child "$transcript_cwd" "$cwd"; then
+        return 1
     fi
 
-    if [[ "$target_dir" == "$HOME/"* ]]; then
-        echo "${target_dir#$HOME/}"
-    elif [ "$target_dir" = "$HOME" ]; then
-        echo "$name"
-    else
-        echo "${target_dir#/}"
+    project=$(eagle_project_from_path_no_git "$transcript_cwd")
+    [ -n "$project" ] || return 1
+    printf '%s\n' "$project"
+}
+
+eagle_project_from_hook_input() {
+    local input="${1:-}"
+
+    if [ -n "${EAGLE_MEM_PROJECT:-}" ]; then
+        echo "$EAGLE_MEM_PROJECT"
+        return
     fi
+
+    local cwd transcript_path project
+    cwd=$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)
+    transcript_path=$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)
+
+    if project=$(eagle_project_from_claude_transcript "$transcript_path" "$cwd"); then
+        printf '%s\n' "$project"
+        return
+    fi
+
+    eagle_project_from_cwd "$cwd"
 }
 
 eagle_project_file_path() {
@@ -761,6 +905,7 @@ Eagle Mem hooks are active for Codex in this project. SessionStart and UserPromp
 - Attribute recalled context as "Eagle Mem recalls:" when it is injected
 - Use the Eagle Mem skills when relevant: `eagle-mem-search`, `eagle-mem-overview`, `eagle-mem-memories`, `eagle-mem-tasks`, and `eagle-mem-orchestrate`
 - For broad multi-agent work, YOU run `eagle-mem orchestrate`; do not ask the user to run these commands
+- Codex does not currently expose a persistent custom statusline like Claude Code; if the user asks for Eagle Mem status, run `eagle-mem statusline`
 - For important decisions, preferences, gotchas, or durable project facts, include them briefly in normal prose. Eagle Mem will extract them from the transcript.
 - Do not revert Eagle Mem-surfaced decisions without asking the user
 - If Eagle Mem reports pending feature verification, verify or waive it before push/PR/publish
@@ -779,7 +924,8 @@ eagle_patch_codex_agents_md() {
             || grep -qF 'emit an <eagle-summary> block' "$agents_md" 2>/dev/null \
             || grep -qF 'explicitly include them in the `<eagle-summary>` block' "$agents_md" 2>/dev/null \
             || grep -qF 'explicitly include them in the <eagle-summary> block' "$agents_md" 2>/dev/null \
-            || ! grep -qF 'Keep Codex final answers clean' "$agents_md" 2>/dev/null; then
+            || ! grep -qF 'Keep Codex final answers clean' "$agents_md" 2>/dev/null \
+            || ! grep -qF 'eagle-mem statusline' "$agents_md" 2>/dev/null; then
             local tmp_md
             tmp_md=$(mktemp)
             awk -v marker="$marker" '

package/lib/db-backfill.sh

@@ -6,22 +6,41 @@
 _EAGLE_DB_BACKFILL_LOADED=1
 
 eagle_build_session_project_map() {
+    local session_filter_file="${1:-}"
     local claude_projects_dir="$EAGLE_CLAUDE_PROJECTS_DIR"
     [ ! -d "$claude_projects_dir" ] && return 0
 
+    if [ -n "$session_filter_file" ] && [ -s "$session_filter_file" ]; then
+        local transcript_index project_cache
+        transcript_index=$(mktemp)
+        project_cache=$(mktemp)
+        find "$claude_projects_dir" -mindepth 2 -maxdepth 2 -name "*.jsonl" -print > "$transcript_index" 2>/dev/null || true
+
+        local sid jsonl proj_dir project cached
+        while IFS= read -r sid; do
+            [ -z "$sid" ] && continue
+            jsonl=$(grep -m 1 "/$sid.jsonl\$" "$transcript_index" 2>/dev/null || true)
+            [ -f "$jsonl" ] || continue
+
+            proj_dir=$(dirname "$jsonl")
+            cached=$(grep -m 1 "^$proj_dir|" "$project_cache" 2>/dev/null || true)
+            if [ -n "$cached" ]; then
+                project="${cached#*|}"
+            else
+                project=$(eagle_project_from_claude_project_dir "$proj_dir" 2>/dev/null || true)
+                printf '%s|%s\n' "$proj_dir" "$project" >> "$project_cache"
+            fi
+            [ -n "$project" ] && echo "$sid|$project"
+        done < "$session_filter_file"
+        rm -f "$transcript_index" "$project_cache"
+        return 0
+    fi
+
     for proj_dir in "$claude_projects_dir"/*/; do
         [ ! -d "$proj_dir" ] && continue
 
         local project=""
-        local sample_jsonl
-        sample_jsonl=$(ls "$proj_dir"*.jsonl 2>/dev/null | head -1)
-        if [ -n "$sample_jsonl" ] && [ -f "$sample_jsonl" ]; then
-            local cwd
-            cwd=$(head -10 "$sample_jsonl" | jq -r 'select(.cwd != null) | .cwd' 2>/dev/null | head -1)
-            if [ -n "$cwd" ]; then
-                project=$(eagle_project_from_cwd "$cwd")
-            fi
-        fi
+        project=$(eagle_project_from_claude_project_dir "$proj_dir" 2>/dev/null || true)
         [ -z "$project" ] && continue
 
         for jsonl in "$proj_dir"*.jsonl; do
@@ -33,36 +52,55 @@ eagle_build_session_project_map() {
     done
 }
 
+eagle_build_claude_project_dir_map() {
+    local claude_projects_dir="$EAGLE_CLAUDE_PROJECTS_DIR"
+    [ ! -d "$claude_projects_dir" ] && return 0
+
+    for proj_dir in "$claude_projects_dir"/*/; do
+        [ ! -d "$proj_dir" ] && continue
+
+        local project
+        project=$(eagle_project_from_claude_project_dir "$proj_dir" 2>/dev/null || true)
+        [ -z "$project" ] && continue
+
+        printf '%s|%s\n' "${proj_dir%/}" "$project"
+    done
+}
+
 eagle_backfill_projects() {
     local updated=0
-    local map
-    map=$(eagle_build_session_project_map)
-    [ -z "$map" ] && echo "0" && return 0
+    local session_filter_file map
+    session_filter_file=$(mktemp)
+    eagle_db "SELECT id FROM sessions;" > "$session_filter_file" 2>/dev/null || true
+    map=$(eagle_build_session_project_map "$session_filter_file")
 
     # Phase 1: Build old→new project mapping BEFORE mutating any rows.
     # Collect from sessions table so non-session tables can be migrated.
     local rename_map_file
     rename_map_file=$(mktemp)
-    while IFS='|' read -r sid project; do
-        [ -z "$sid" ] || [ -z "$project" ] && continue
-        local sid_sql
-        sid_sql=$(eagle_sql_escape "$sid")
-        local old_project
-        old_project=$(eagle_db "SELECT project FROM sessions WHERE id = '$sid_sql';")
-        if [ -n "$old_project" ] && [ "$old_project" != "$project" ]; then
-            echo "$old_project|$project" >> "$rename_map_file"
-        fi
-    done <<< "$map"
+    if [ -n "$map" ]; then
+        while IFS='|' read -r sid project; do
+            [ -z "$sid" ] || [ -z "$project" ] && continue
+            local sid_sql
+            sid_sql=$(eagle_sql_escape "$sid")
+            local old_project
+            old_project=$(eagle_db "SELECT project FROM sessions WHERE id = '$sid_sql';")
+            if [ -n "$old_project" ] && [ "$old_project" != "$project" ]; then
+                echo "$old_project|$project" >> "$rename_map_file"
+            fi
+        done <<< "$map"
+    fi
 
     # Phase 2: Update session-linked tables
-    while IFS='|' read -r sid project; do
-        [ -z "$sid" ] || [ -z "$project" ] && continue
-        local sid_sql proj_sql
-        sid_sql=$(eagle_sql_escape "$sid")
-        proj_sql=$(eagle_sql_escape "$project")
-
-        local ch
-        ch=$(eagle_db_pipe <<SQL
+    if [ -n "$map" ]; then
+        while IFS='|' read -r sid project; do
+            [ -z "$sid" ] || [ -z "$project" ] && continue
+            local sid_sql proj_sql
+            sid_sql=$(eagle_sql_escape "$sid")
+            proj_sql=$(eagle_sql_escape "$project")
+
+            local ch
+            ch=$(eagle_db_pipe <<SQL
 BEGIN;
 UPDATE sessions SET project = '$proj_sql' WHERE id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
 UPDATE agent_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
@@ -73,11 +111,38 @@ UPDATE observations SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND
 SELECT total_changes();
 COMMIT;
 SQL
+)
+            [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
+        done <<< "$map"
+    fi
+
+    # Phase 3: Repair Claude memory rows that have no session id but live under
+    # a Claude project directory. These rows used to keep stale project keys
+    # when their file content did not change.
+    local dir_map
+    dir_map=$(eagle_build_claude_project_dir_map)
+    while IFS='|' read -r proj_dir project; do
+        [ -z "$proj_dir" ] || [ -z "$project" ] && continue
+        local proj_sql prefix_sql
+        proj_sql=$(eagle_sql_escape "$project")
+        prefix_sql=$(eagle_sql_escape "$proj_dir/memory/")
+
+        local ch
+        ch=$(eagle_db_pipe <<SQL
+BEGIN;
+UPDATE agent_memories
+SET project = '$proj_sql'
+WHERE file_path >= '$prefix_sql'
+  AND file_path < ('$prefix_sql' || char(0x10ffff))
+  AND (project = '' OR project != '$proj_sql');
+SELECT total_changes();
+COMMIT;
+SQL
 )
         [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
-    done <<< "$map"
+    done <<< "$dir_map"
 
-    # Phase 3: Update non-session tables using the old→new mapping.
+    # Phase 4: Update non-session tables using the old→new mapping.
     # Skip ambiguous mappings (one old name → multiple new names).
     if [ -s "$rename_map_file" ]; then
         local uniq_map
@@ -121,7 +186,7 @@ COMMIT;
 SQL
         done <<< "$uniq_map"
     fi
-    rm -f "$rename_map_file"
+    rm -f "$rename_map_file" "$session_filter_file"
 
     echo "$updated"
 }

package/lib/db-mirrors.sh

@@ -63,18 +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 = excluded.origin_session_id,
-    origin_agent    = excluded.origin_agent,
-    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
-WHERE agent_memories.content_hash != excluded.content_hash;
+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
 }
 
@@ -147,17 +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;
+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
 }
 
@@ -245,20 +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;
+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/package.json

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

package/scripts/help.sh

@@ -32,6 +32,7 @@ echo -e "  ${BOLD}Safety and token controls:${RESET}"
 echo -e "    ${CYAN}feature${RESET}     Track, verify, and unblock feature changes"
 echo -e "    ${CYAN}guard${RESET}       Manage regression guardrails for files"
 echo -e "    ${CYAN}config${RESET}      View/change providers, RTK, and token guard settings"
+echo -e "    ${CYAN}statusline${RESET}  Print compact Eagle Mem statusline"
 echo ""
 echo -e "  ${BOLD}Automation and coordination:${RESET}"
 echo -e "    ${CYAN}curate${RESET}      Run curator (co-edits, hot files, guardrails)"

package/scripts/install.sh

@@ -52,6 +52,26 @@ install_package() {
     esac
 }
 
+ensure_rtk() {
+    if command -v rtk &>/dev/null; then
+        rtk_version=$(rtk --version 2>/dev/null | head -1)
+        eagle_ok "RTK ${DIM}(${rtk_version:-installed})${RESET}"
+        return 0
+    fi
+
+    eagle_warn "RTK not found ${DIM}(token guard will be advisory until installed)${RESET}"
+    if command -v cargo &>/dev/null; then
+        eagle_info "Installing RTK with Cargo: cargo install rtk"
+        if cargo install rtk; then
+            eagle_ok "RTK installed"
+        else
+            eagle_warn "RTK install failed ${DIM}(continuing; run 'cargo install rtk' later)${RESET}"
+        fi
+    else
+        eagle_dim "Install Rust/Cargo, then run: cargo install rtk"
+    fi
+}
+
 # ─── Check prerequisites ───────────────────────────────────
 
 echo -e "  ${BOLD}Checking prerequisites...${RESET}"
@@ -118,6 +138,10 @@ else
     fi
 fi
 
+# RTK is optional, but Eagle Mem can use it for both Claude Code and Codex
+# token-guard behavior when it is available on PATH.
+ensure_rtk
+
 # Claude Code / Codex
 claude_found=false
 codex_found=false
@@ -283,8 +307,9 @@ if [ "$claude_found" = true ]; then
 #!/usr/bin/env bash
 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"
+eagle_mem_statusline "$project_dir" "$session_id"
 WRAPPER
         chmod +x "$wrapper"
         tmp=$(mktemp)
@@ -303,7 +328,7 @@ WRAPPER
             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\")"
+            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}"

package/scripts/memories.sh

@@ -455,17 +455,20 @@ memories_sync() {
             base=$(basename "$memfile")
             [ "$base" = "MEMORY.md" ] && continue
 
-            local existing_hash
-            existing_hash=$(eagle_db "SELECT content_hash FROM agent_memories WHERE file_path = '$(eagle_sql_escape "$memfile")';")
+            local mem_project mem_project_dir existing_row existing_hash existing_project
+            mem_project_dir="${memfile%/memory/*}"
+            mem_project=$(eagle_project_from_claude_project_dir "$mem_project_dir" 2>/dev/null || true)
+            existing_row=$(eagle_db "SELECT content_hash, project FROM agent_memories WHERE file_path = '$(eagle_sql_escape "$memfile")';")
+            IFS='|' read -r existing_hash existing_project <<< "$existing_row"
             local new_hash
             new_hash=$(shasum -a 256 "$memfile" | awk '{print $1}')
 
-            if [ "$existing_hash" = "$new_hash" ]; then
+            if [ "$existing_hash" = "$new_hash" ] && { [ -z "$mem_project" ] || [ "$existing_project" = "$mem_project" ]; }; then
                 mem_skipped=$((mem_skipped + 1))
                 continue
             fi
 
-            eagle_capture_agent_memory "$memfile" "" ""
+            eagle_capture_agent_memory "$memfile" "" "$mem_project" "claude-code"
             mem_synced=$((mem_synced + 1))
             eagle_ok "Memory: $base"
         done < <(find "$claude_mem_root" -path "*/memory/*.md" -print0 2>/dev/null)
@@ -478,12 +481,13 @@ memories_sync() {
         for memfile in "$codex_mem_root/MEMORY.md" "$codex_mem_root/memory_summary.md"; do
             [ ! -f "$memfile" ] && continue
 
-            local existing_hash
-            existing_hash=$(eagle_db "SELECT content_hash FROM agent_memories WHERE file_path = '$(eagle_sql_escape "$memfile")';")
+            local existing_row existing_hash existing_project
+            existing_row=$(eagle_db "SELECT content_hash, project FROM agent_memories WHERE file_path = '$(eagle_sql_escape "$memfile")';")
+            IFS='|' read -r existing_hash existing_project <<< "$existing_row"
             local new_hash
             new_hash=$(shasum -a 256 "$memfile" | awk '{print $1}')
 
-            if [ "$existing_hash" = "$new_hash" ]; then
+            if [ "$existing_hash" = "$new_hash" ] && [ "$existing_project" = "$codex_project" ]; then
                 mem_skipped=$((mem_skipped + 1))
                 continue
             fi

package/scripts/statusline-em.sh

@@ -5,6 +5,7 @@
 
 eagle_mem_statusline() {
     local project_dir="${1:-}"
+    local session_id="${2:-}"
     local em_db="$HOME/.eagle-mem/memory.db"
     [ -f "$em_db" ] || return
 
@@ -12,25 +13,49 @@ eagle_mem_statusline() {
     . "$SCRIPT_DIR/../lib/common.sh"
 
     local proj
+    [ -z "$project_dir" ] && project_dir="$(pwd)"
     proj=$(eagle_project_from_cwd "$project_dir")
     [ -z "$proj" ] && return
 
     proj=$(eagle_sql_escape "$proj")
 
-    local cnt mem
+    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}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
     mem=$(echo ".headers off
 SELECT COUNT(*) FROM agent_memories WHERE project = '${proj}';" | sqlite3 "$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
+        turns=$(find "$HOME/.eagle-mem" -name '.turn-counter.*' -type f -mtime -1 -print 2>/dev/null \
+            | while IFS= read -r f; do
+                tr -d '[:space:]' < "$f" 2>/dev/null
+                echo ""
+            done \
+            | awk '($1+0)>max{max=$1+0} END{print max+0}')
+    fi
     cnt=${cnt:-0}; mem=${mem:-0}
+    turns=${turns:-0}
 
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
-    printf "%bEagle Mem%b %b%s%b ses %b%s%b mem" "$CYAN" "$R" "$WHT" "$cnt" "$DIM" "$WHT" "$mem" "$R"
+    printf "%bEM%b %bv%s%b ses %b%s%b mem %b%s%b turns %b%s%b" \
+        "$CYAN" "$R" \
+        "$WHT" "$version" "$DIM" \
+        "$WHT" "$cnt" "$DIM" \
+        "$WHT" "$mem" "$DIM" \
+        "$WHT" "$turns" "$R"
 }
 
 # When run directly, read project_dir from stdin JSON (statusline format)
 if [ "${BASH_SOURCE[0]}" = "$0" ]; then
-    input=$(cat)
-    project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""' 2>/dev/null)
-    eagle_mem_statusline "$project_dir"
+    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"
 fi

package/scripts/update.sh

@@ -143,6 +143,22 @@ if [ "$codex_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
     eagle_ok "Codex skills updated"
 fi
 
+# ─── Refresh generated Claude statusline wrapper ───────────
+
+statusline_wrapper="$EAGLE_MEM_DIR/scripts/statusline-wrapper.sh"
+if [ -f "$statusline_wrapper" ]; then
+    cat > "$statusline_wrapper" << 'WRAPPER'
+#!/usr/bin/env bash
+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"
+WRAPPER
+    chmod +x "$statusline_wrapper"
+    eagle_ok "Statusline wrapper updated"
+fi
+
 # ─── Backfill project names ───────────────────────────────
 
 backfilled=$(eagle_backfill_projects 2>/dev/null)