eagle-mem 4.9.3 → 4.9.5

package/README.md

@@ -11,7 +11,7 @@
 
 Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code and Codex the same local memory, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
 
-**v4.8.5 hardens first-run setup:** `eagle-mem config init` now falls through cleanly when Ollama is not running, and DB-backed commands fail loudly when the active `sqlite3` lacks FTS5 support.
+**v4.9.5 hardens hooks and SQLite:** Stop hooks save immediately and queue LLM enrichment in the background instead of launching nested agents during turn shutdown. SQLite calls also resolve through one FTS5-capable binary selector, so Android SDK or other PATH shims do not accidentally break Eagle Mem.
 
 **Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
 [Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |
@@ -73,7 +73,7 @@ For Codex, the installer enables `codex_hooks` in `~/.codex/config.toml`, regist
 
 ### Prerequisites
 
-- `sqlite3` with FTS5 support (ships with macOS; the installer offers to install if missing)
+- `sqlite3` with FTS5 support (ships with macOS; Eagle Mem prefers known system/Homebrew SQLite binaries before PATH shims)
 - `jq` (the installer offers to install if missing)
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, or both installed
 
@@ -87,7 +87,7 @@ Hooks fire automatically at different points in the agent lifecycle:
 | **PreToolUse** | before Bash/shell, Read, Edit, Write, apply_patch | Surfaces guardrails and decisions before edits. Blocks release-boundary commands while feature verification is pending. Rewrites noisy commands through RTK when available. Detects redundant reads, nudges co-edit partners, detects stuck loops. |
 | **UserPromptSubmit** | user sends a message | FTS5 search across past sessions and indexed code for relevant context |
 | **PostToolUse** | after tool calls | Records file touches, mirrors memory/plan/task writes, surfaces decision history and feature impacts on reads, stale memory warnings on edits |
-| **Stop** | agent turn ends | Extracts `<eagle-summary>` blocks for rich session summaries from Claude Code and Codex transcripts |
+| **Stop** | agent turn ends | Saves fast heuristic summaries and extracts `<eagle-summary>` blocks when present. LLM enrichment runs later in the background so the agent lifecycle is not blocked. |
 | **SessionEnd** | session closes | Re-syncs tasks, marks session completed |
 
 Codex shell hooks are registered for `Bash`, `exec_command`, `shell_command`, and `unified_exec` tool names so release-boundary protection works across current Codex shell paths.
@@ -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.5 Patch
+
+Stop hooks now use a fast path: they save heuristic summaries immediately, extract explicit summary blocks when present, and queue LLM enrichment in the background so Codex/Claude lifecycle hooks do not time out. SQLite access now goes through a shared FTS5-capable binary resolver used by migrations, DB helpers, updater backups, install checks, and the statusline, avoiding Android SDK or other PATH shims that shadow working SQLite builds.
+
+### 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/db/migrate.sh

@@ -13,11 +13,12 @@ COMMON_SH="$SCRIPT_DIR/../lib/common.sh"
 if [ -f "$COMMON_SH" ]; then
     . "$COMMON_SH"
     eagle_require_sqlite_fts5 || exit 1
+    SQLITE_BIN=$(eagle_sqlite_path)
 else
-    sqlite_path=$(command -v sqlite3 2>/dev/null || true)
-    if [ -z "$sqlite_path" ] || ! sqlite3 :memory: "CREATE VIRTUAL TABLE eagle_mem_fts5_probe USING fts5(value);" >/dev/null 2>&1; then
+    SQLITE_BIN=$(command -v sqlite3 2>/dev/null || true)
+    if [ -z "$SQLITE_BIN" ] || ! "$SQLITE_BIN" :memory: "CREATE VIRTUAL TABLE eagle_mem_fts5_probe USING fts5(value);" >/dev/null 2>&1; then
         echo "Eagle Mem requires SQLite FTS5, but the active sqlite3 does not support it." >&2
-        [ -n "$sqlite_path" ] && echo "Detected sqlite3: $sqlite_path" >&2
+        [ -n "$SQLITE_BIN" ] && echo "Detected sqlite3: $SQLITE_BIN" >&2
         echo "Fix PATH so an FTS5-capable sqlite3 is first, then re-run the command." >&2
         exit 1
     fi
@@ -33,7 +34,7 @@ run_migration() {
     local file="$2"
 
     local already_applied
-    already_applied=$(sqlite3 "$DB" "SELECT COUNT(*) FROM _migrations WHERE name = '$name';" 2>/dev/null || echo "0")
+    already_applied=$("$SQLITE_BIN" "$DB" "SELECT COUNT(*) FROM _migrations WHERE name = '$name';" 2>/dev/null || echo "0")
 
     if [ "$already_applied" = "0" ]; then
         # Strip PRAGMAs from migration body (they can't run inside transactions
@@ -43,20 +44,20 @@ run_migration() {
 
         # Set connection PRAGMAs, then run migration body + tracking insert atomically
         # .bail on ensures sqlite3 stops on the first error instead of continuing
-        { echo ".bail on"; echo "PRAGMA trusted_schema=ON;"; echo "PRAGMA foreign_keys=ON;"; echo "PRAGMA busy_timeout=5000;"; echo "BEGIN;"; echo "$body"; echo "INSERT INTO _migrations (name) VALUES ('$name');"; echo "COMMIT;"; } | sqlite3 "$DB"
+        { echo ".bail on"; echo "PRAGMA trusted_schema=ON;"; echo "PRAGMA foreign_keys=ON;"; echo "PRAGMA busy_timeout=5000;"; echo "BEGIN;"; echo "$body"; echo "INSERT INTO _migrations (name) VALUES ('$name');"; echo "COMMIT;"; } | "$SQLITE_BIN" "$DB"
         echo "  applied: $name"
     fi
 }
 
 # Ensure _migrations table exists (bootstrap)
-sqlite3 "$DB" "CREATE TABLE IF NOT EXISTS _migrations (
+"$SQLITE_BIN" "$DB" "CREATE TABLE IF NOT EXISTS _migrations (
     id         INTEGER PRIMARY KEY,
     name       TEXT    NOT NULL UNIQUE,
     applied_at TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
 );"
 
 # Set PRAGMAs (these must be set on every connection)
-sqlite3 "$DB" "PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;"
+"$SQLITE_BIN" "$DB" "PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;"
 
 # ─── Migration 001: Initial schema (special name) ──────────
 run_migration "001_initial_schema" "$SCRIPT_DIR/schema.sql"

package/hooks/stop.sh

@@ -223,6 +223,7 @@ if echo "$request" | grep -qE '<(local-command-caveat|system-reminder|command-na
 fi
 
 needs_enrichment=0
+defer_enrichment=0
 if [ "$has_rich_data" -eq 0 ]; then
     needs_enrichment=1
 elif [ "$context_pressure" -eq 1 ]; then
@@ -235,7 +236,13 @@ fi
 
 if [ "$needs_enrichment" -eq 1 ]; then
     provider=$(eagle_config_get "provider" "type" "none" 2>/dev/null)
-    if [ "$provider" != "none" ] && [ -n "$text_content" ]; then
+    # Stop hooks must stay fast. Expensive LLM enrichment belongs in curate or
+    # another background path; nested agent_cli calls can exceed Codex/Claude
+    # lifecycle timeouts and make the hook look broken to users.
+    if [ "${EAGLE_MEM_STOP_ENRICH:-0}" != "1" ]; then
+        defer_enrichment=1
+        eagle_log "INFO" "Stop: LLM enrichment skipped — fast hook path (provider=$provider)"
+    elif [ "$provider" != "none" ] && [ -n "$text_content" ]; then
         excerpt=$(echo "$text_content" | tail -c 3000)
 
         enrich_prompt="Extract facts from this AI coding session. Only include items with clear evidence in the session text. Do NOT invent or repeat example content.
@@ -401,4 +408,26 @@ if [ -n "$request" ] || [ -n "$completed" ] || [ -n "$learned" ]; then
     fi
 fi
 
+if [ "$defer_enrichment" -eq 1 ] && [ "${EAGLE_MEM_STOP_BACKGROUND_ENRICH:-1}" = "1" ] && [ -n "$text_content" ]; then
+    mkdir -p "$EAGLE_MEM_DIR/tmp" 2>/dev/null || true
+    enrich_job=$(mktemp "$EAGLE_MEM_DIR/tmp/summary-enrich.XXXXXX.json" 2>/dev/null)
+    if [ -n "$enrich_job" ]; then
+        jq -cn \
+            --arg session_id "$session_id" \
+            --arg project "$project" \
+            --arg agent "$agent" \
+            --arg text "$text_content" \
+            '{session_id:$session_id, project:$project, agent:$agent, text:$text}' > "$enrich_job"
+
+        enrich_script="$SCRIPT_DIR/../scripts/enrich-summary.sh"
+        if [ -x "$enrich_script" ]; then
+            nohup env EAGLE_MEM_DISABLE_HOOKS=1 EAGLE_AGENT_SOURCE="$agent" EAGLE_AGENT_CWD="$cwd" bash "$enrich_script" "$enrich_job" >/dev/null 2>&1 &
+            eagle_log "INFO" "Stop: queued background summary enrichment for session=$session_id"
+        else
+            rm -f "$enrich_job" 2>/dev/null || true
+            eagle_log "WARN" "Stop: background enrichment script missing: $enrich_script"
+        fi
+    fi
+fi
+
 exit 0

package/lib/codex-hooks.sh

@@ -163,7 +163,7 @@ eagle_register_codex_hooks() {
         "EAGLE_AGENT_SOURCE=codex bash \"$EAGLE_MEM_DIR/hooks/stop.sh\"" \
         "Codex Stop hook" \
         "Saving Eagle Mem summary" \
-        "30"
+        "60"
 }
 
 eagle_remove_codex_hooks() {

package/lib/common.sh

@@ -20,24 +20,63 @@ EAGLE_CODEX_SKILLS_DIR="${EAGLE_CODEX_SKILLS_DIR:-$EAGLE_CODEX_DIR/skills}"
 EAGLE_CODEX_MEMORIES_DIR="${EAGLE_CODEX_MEMORIES_DIR:-$EAGLE_CODEX_DIR/memories}"
 EAGLE_RAW_BASH_UNLOCK="${EAGLE_RAW_BASH_UNLOCK:-/tmp/eagle-mem-raw-bash-unlock}"
 
+_eagle_sqlite_candidate_paths() {
+    [ -n "${EAGLE_SQLITE_BIN:-}" ] && printf '%s\n' "$EAGLE_SQLITE_BIN"
+    [ -f "$EAGLE_MEM_DIR/.sqlite-bin" ] && sed -n '1p' "$EAGLE_MEM_DIR/.sqlite-bin" 2>/dev/null
+    printf '%s\n' \
+        "/opt/homebrew/opt/sqlite/bin/sqlite3" \
+        "/usr/local/opt/sqlite/bin/sqlite3" \
+        "/usr/bin/sqlite3" \
+        "/opt/homebrew/bin/sqlite3" \
+        "/usr/local/bin/sqlite3"
+    command -v sqlite3 2>/dev/null || true
+}
+
+_eagle_sqlite_bin_supports_fts5() {
+    local bin="$1"
+    [ -n "$bin" ] && [ -x "$bin" ] || return 1
+    "$bin" :memory: "CREATE VIRTUAL TABLE eagle_mem_fts5_probe USING fts5(value);" >/dev/null 2>&1
+}
+
 eagle_sqlite_path() {
+    local seen="" candidate
+    while IFS= read -r candidate; do
+        [ -n "$candidate" ] || continue
+        case "|$seen|" in *"|$candidate|"*) continue ;; esac
+        seen="${seen}|${candidate}"
+        if _eagle_sqlite_bin_supports_fts5 "$candidate"; then
+            printf '%s\n' "$candidate"
+            return 0
+        fi
+    done <<EOF
+$(_eagle_sqlite_candidate_paths)
+EOF
+
     command -v sqlite3 2>/dev/null || true
 }
 
 eagle_sqlite_version() {
-    sqlite3 --version 2>/dev/null | awk '{print $1}'
+    local sqlite_bin
+    sqlite_bin=$(eagle_sqlite_path)
+    [ -n "$sqlite_bin" ] || return 0
+    "$sqlite_bin" --version 2>/dev/null | awk '{print $1}'
 }
 
 eagle_sqlite_supports_fts5() {
-    command -v sqlite3 >/dev/null 2>&1 || return 1
-    sqlite3 :memory: "CREATE VIRTUAL TABLE eagle_mem_fts5_probe USING fts5(value);" >/dev/null 2>&1
+    local sqlite_bin
+    sqlite_bin=$(eagle_sqlite_path)
+    _eagle_sqlite_bin_supports_fts5 "$sqlite_bin"
 }
 
 eagle_print_sqlite_fts5_error() {
     local sqlite_path sqlite_version probe_error
     sqlite_path=$(eagle_sqlite_path)
     sqlite_version=$(eagle_sqlite_version)
-    probe_error=$(sqlite3 :memory: "CREATE VIRTUAL TABLE eagle_mem_fts5_probe USING fts5(value);" 2>&1 >/dev/null || true)
+    if [ -n "$sqlite_path" ]; then
+        probe_error=$("$sqlite_path" :memory: "CREATE VIRTUAL TABLE eagle_mem_fts5_probe USING fts5(value);" 2>&1 >/dev/null || true)
+    else
+        probe_error=""
+    fi
 
     printf '%s\n' "Eagle Mem requires SQLite FTS5, but the active sqlite3 does not support it." >&2
     if [ -n "$sqlite_path" ]; then
@@ -47,8 +86,8 @@ eagle_print_sqlite_fts5_error() {
     fi
     [ -n "$sqlite_version" ] && printf '%s\n' "SQLite version: $sqlite_version" >&2
     [ -n "$probe_error" ] && printf '%s\n' "SQLite error: $probe_error" >&2
-    printf '%s\n' "Fix: put an FTS5-capable sqlite3 earlier in PATH, then re-run the command." >&2
-    printf '%s\n' "macOS: check 'command -v sqlite3'; /usr/bin/sqlite3 usually has FTS5. If Android SDK platform-tools is first, move it later in PATH." >&2
+    printf '%s\n' "Fix: install an FTS5-capable sqlite3, or set EAGLE_SQLITE_BIN to its absolute path." >&2
+    printf '%s\n' "macOS: /usr/bin/sqlite3 usually has FTS5. Eagle Mem now prefers known system/Homebrew sqlite3 paths over Android SDK shims." >&2
     printf '%s\n' "Homebrew: install sqlite and prepend its bin directory, for example: export PATH=\"/opt/homebrew/opt/sqlite/bin:\$PATH\"" >&2
     printf '%s\n' "Linux: install a sqlite3 package compiled with ENABLE_FTS5." >&2
 }
@@ -210,14 +249,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 +484,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 +508,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 +521,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 +1104,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-core.sh

@@ -15,10 +15,13 @@ PRAGMA trusted_schema=ON;
 .output stdout"
 
 eagle_db() {
+    local _eagle_sqlite_bin
+    _eagle_sqlite_bin=$(eagle_sqlite_path)
+    [ -n "$_eagle_sqlite_bin" ] || return 1
     local _eagle_db_err
     _eagle_db_err=$(mktemp 2>/dev/null || echo "/tmp/_eagle_db_err.$$")
     local _eagle_db_out
-    _eagle_db_out=$({ echo "$EAGLE_DB_SETUP"; echo "$*"; } | sqlite3 "$EAGLE_MEM_DB" 2>"$_eagle_db_err")
+    _eagle_db_out=$({ echo "$EAGLE_DB_SETUP"; echo "$*"; } | "$_eagle_sqlite_bin" "$EAGLE_MEM_DB" 2>"$_eagle_db_err")
     local _eagle_db_rc=$?
     if [ -s "$_eagle_db_err" ]; then
         cat "$_eagle_db_err" >> "$EAGLE_MEM_LOG" 2>/dev/null
@@ -29,10 +32,13 @@ eagle_db() {
 }
 
 eagle_db_pipe() {
+    local _eagle_sqlite_bin
+    _eagle_sqlite_bin=$(eagle_sqlite_path)
+    [ -n "$_eagle_sqlite_bin" ] || return 1
     local _eagle_db_err
     _eagle_db_err=$(mktemp 2>/dev/null || echo "/tmp/_eagle_db_pipe_err.$$")
     local _eagle_db_out
-    _eagle_db_out=$({ echo "$EAGLE_DB_SETUP"; echo ".bail on"; cat; } | sqlite3 "$EAGLE_MEM_DB" 2>"$_eagle_db_err")
+    _eagle_db_out=$({ echo "$EAGLE_DB_SETUP"; echo ".bail on"; cat; } | "$_eagle_sqlite_bin" "$EAGLE_MEM_DB" 2>"$_eagle_db_err")
     local _eagle_db_rc=$?
     if [ -s "$_eagle_db_err" ]; then
         cat "$_eagle_db_err" >> "$EAGLE_MEM_LOG" 2>/dev/null
@@ -43,10 +49,13 @@ eagle_db_pipe() {
 }
 
 eagle_db_json() {
+    local _eagle_sqlite_bin
+    _eagle_sqlite_bin=$(eagle_sqlite_path)
+    [ -n "$_eagle_sqlite_bin" ] || return 1
     local _eagle_db_err
     _eagle_db_err=$(mktemp 2>/dev/null || echo "/tmp/_eagle_db_json_err.$$")
     local _eagle_db_out
-    _eagle_db_out=$({ echo "$EAGLE_DB_SETUP"; echo ".mode json"; echo "$*"; } | sqlite3 "$EAGLE_MEM_DB" 2>"$_eagle_db_err")
+    _eagle_db_out=$({ echo "$EAGLE_DB_SETUP"; echo ".mode json"; echo "$*"; } | "$_eagle_sqlite_bin" "$EAGLE_MEM_DB" 2>"$_eagle_db_err")
     local _eagle_db_rc=$?
     if [ -s "$_eagle_db_err" ]; then
         cat "$_eagle_db_err" >> "$EAGLE_MEM_LOG" 2>/dev/null

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/lib/updater.sh

@@ -186,8 +186,10 @@ eagle_update_backup_runtime() {
     done
 
     if [ -f "$EAGLE_MEM_DB" ]; then
-        if command -v sqlite3 >/dev/null 2>&1; then
-            sqlite3 "$EAGLE_MEM_DB" ".backup '$backup_dir/memory.db'" >/dev/null 2>&1 || cp "$EAGLE_MEM_DB" "$backup_dir/memory.db" 2>/dev/null || true
+        local sqlite_bin
+        sqlite_bin=$(eagle_sqlite_path)
+        if [ -n "$sqlite_bin" ]; then
+            "$sqlite_bin" "$EAGLE_MEM_DB" ".backup '$backup_dir/memory.db'" >/dev/null 2>&1 || cp "$EAGLE_MEM_DB" "$backup_dir/memory.db" 2>/dev/null || true
         else
             cp "$EAGLE_MEM_DB" "$backup_dir/memory.db" 2>/dev/null || true
         fi

package/package.json

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

package/scripts/enrich-summary.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# Eagle Mem — background summary enrichment
+# Runs outside lifecycle hook timeouts. Input is a JSON job file created by Stop.
+set +e
+[ "${EAGLE_MEM_DISABLE_BACKGROUND_ENRICH:-}" = "1" ] && exit 0
+
+job_file="${1:-}"
+[ -n "$job_file" ] && [ -f "$job_file" ] || exit 0
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPT_DIR/../lib"
+
+. "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
+. "$LIB_DIR/provider.sh"
+
+eagle_ensure_db || exit 0
+
+session_id=$(jq -r '.session_id // empty' "$job_file" 2>/dev/null)
+project=$(jq -r '.project // empty' "$job_file" 2>/dev/null)
+agent=$(jq -r '.agent // empty' "$job_file" 2>/dev/null)
+text_content=$(jq -r '.text // empty' "$job_file" 2>/dev/null)
+
+if [ -z "$session_id" ] || [ -z "$project" ] || [ -z "$text_content" ]; then
+    rm -f "$job_file" 2>/dev/null || true
+    exit 0
+fi
+
+provider=$(eagle_config_get "provider" "type" "none" 2>/dev/null)
+if [ "$provider" = "none" ]; then
+    eagle_log "INFO" "Summary enrichment skipped: no provider for session=$session_id"
+    rm -f "$job_file" 2>/dev/null || true
+    exit 0
+fi
+
+excerpt=$(printf '%s' "$text_content" | tail -c 3000)
+
+enrich_prompt="Extract facts from this AI coding session. Only include items with clear evidence in the session text. Do NOT invent or repeat example content.
+
+Respond with EXACTLY these sections (omit sections with no evidence):
+
+REQUEST:
+One-line summary of what the user asked for. No system tags or XML.
+
+COMPLETED:
+What was actually accomplished. Be specific about changes made.
+
+LEARNED:
+Non-obvious discoveries or insights from the session.
+
+DECISIONS:
+Each as: <what was decided> — why: <reason>
+
+GOTCHAS:
+Each as: <surprising finding or pitfall>
+
+KEY_FILES:
+Each as: <filepath>
+
+SESSION TEXT:
+$excerpt"
+
+enrich_system="You extract structured facts from Claude Code and Codex development sessions. Output format for decisions: '- Did X — why: Y'. Output format for gotchas: '- Gotcha description'. Be concise. Only include items with clear evidence in the session text. Never fabricate content."
+enrich_result=$(eagle_llm_call "$enrich_prompt" "$enrich_system" 768 2>/dev/null)
+llm_rc=$?
+
+if [ $llm_rc -ne 0 ] || [ -z "$enrich_result" ]; then
+    eagle_log "WARN" "Summary enrichment failed (rc=$llm_rc) for session=$session_id provider=$provider"
+    rm -f "$job_file" 2>/dev/null || true
+    exit 0
+fi
+
+extract_section() {
+    local result="$1" header="$2"
+    printf '%s\n' "$result" | awk -v h="$header:" '
+        $0 == h || $0 ~ "^"h { found=1; next }
+        found && /^[A-Z_]+:/ { exit }
+        found && /^[[:space:]]*$/ { next }
+        found && /^- / { sub(/^- /, ""); lines[++n] = $0; next }
+        found { lines[++n] = $0 }
+        END { for (i=1; i<=n; i++) { printf "%s", lines[i]; if (i<n) printf "; " } }
+    '
+}
+
+request=$(extract_section "$enrich_result" "REQUEST" | eagle_redact)
+completed=$(extract_section "$enrich_result" "COMPLETED" | eagle_redact)
+learned=$(extract_section "$enrich_result" "LEARNED" | eagle_redact)
+decisions=$(extract_section "$enrich_result" "DECISIONS" | eagle_redact)
+gotchas=$(extract_section "$enrich_result" "GOTCHAS" | eagle_redact)
+key_files=$(extract_section "$enrich_result" "KEY_FILES" | eagle_redact)
+
+if [ -n "$request" ] || [ -n "$completed" ] || [ -n "$learned" ] || [ -n "$decisions" ] || [ -n "$gotchas" ] || [ -n "$key_files" ]; then
+    eagle_insert_summary "$session_id" "$project" "$request" "" "$learned" "$completed" "" "[]" "[]" "" "$decisions" "$gotchas" "$key_files" "$agent"
+    eagle_log "INFO" "Summary enrichment saved for session=$session_id provider=$provider"
+fi
+
+rm -f "$job_file" 2>/dev/null || true
+exit 0

package/scripts/install.sh

@@ -80,16 +80,18 @@ echo ""
 prereqs_ok=true
 
 # sqlite3
-if command -v sqlite3 &>/dev/null; then
-    sqlite_version=$(sqlite3 --version 2>/dev/null | awk '{print $1}')
-    eagle_ok "sqlite3 ${DIM}($sqlite_version)${RESET}"
+sqlite_path=$(eagle_sqlite_path)
+if [ -n "$sqlite_path" ]; then
+    sqlite_version=$(eagle_sqlite_version)
+    eagle_ok "sqlite3 ${DIM}($sqlite_version at $sqlite_path)${RESET}"
 else
     eagle_fail "sqlite3 not found"
     if eagle_confirm "Install sqlite3?"; then
         install_package sqlite3
-        if command -v sqlite3 &>/dev/null; then
-            sqlite_version=$(sqlite3 --version 2>/dev/null | awk '{print $1}')
-            eagle_ok "sqlite3 installed ${DIM}($sqlite_version)${RESET}"
+        sqlite_path=$(eagle_sqlite_path)
+        if [ -n "$sqlite_path" ]; then
+            sqlite_version=$("$sqlite_path" --version 2>/dev/null | awk '{print $1}')
+            eagle_ok "sqlite3 installed ${DIM}($sqlite_version at $sqlite_path)${RESET}"
         else
             eagle_fail "sqlite3 installation failed"
             prereqs_ok=false
@@ -100,8 +102,7 @@ else
 fi
 
 # FTS5 support
-if command -v sqlite3 &>/dev/null; then
-    sqlite_path=$(eagle_sqlite_path)
+if [ -n "$sqlite_path" ]; then
     if eagle_sqlite_supports_fts5; then
         eagle_ok "FTS5 support ${DIM}($sqlite_path)${RESET}"
     else
@@ -109,9 +110,9 @@ if command -v sqlite3 &>/dev/null; then
         eagle_dim "Detected sqlite3: $sqlite_path"
         sqlite_version=$(eagle_sqlite_version)
         [ -n "$sqlite_version" ] && eagle_dim "SQLite version: $sqlite_version"
-        eagle_dim "Run: command -v sqlite3"
-        eagle_dim "Fix PATH so an FTS5-capable sqlite3 is first."
-        eagle_dim "macOS: /usr/bin/sqlite3 usually has FTS5; move Android SDK platform-tools later if it shadows sqlite3."
+        eagle_dim "Run: eagle-mem health, or set EAGLE_SQLITE_BIN=/absolute/path/to/sqlite3."
+        eagle_dim "Eagle Mem prefers known system/Homebrew SQLite paths before PATH shims."
+        eagle_dim "macOS: /usr/bin/sqlite3 usually has FTS5; Android SDK sqlite3 shims are ignored when a better binary exists."
         eagle_dim "Homebrew: brew install sqlite, then prepend /opt/homebrew/opt/sqlite/bin or /usr/local/opt/sqlite/bin."
         eagle_dim "Linux: install a sqlite3 package compiled with ENABLE_FTS5."
         prereqs_ok=false
@@ -299,6 +300,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 +311,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,15 +6,19 @@
 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
 
     local SCRIPT_DIR; SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
     . "$SCRIPT_DIR/../lib/common.sh"
+    local sqlite_bin
+    sqlite_bin=$(eagle_sqlite_path)
+    [ -n "$sqlite_bin" ] || return
 
     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")
@@ -23,9 +27,9 @@ eagle_mem_statusline() {
     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:]')
+SELECT COUNT(*) FROM sessions WHERE project = '${proj}';" | "$sqlite_bin" "$em_db" 2>/dev/null | tr -d '[:space:]')
     mem=$(echo ".headers off
-SELECT COUNT(*) FROM agent_memories WHERE project = '${proj}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
+SELECT COUNT(*) FROM agent_memories WHERE project = '${proj}';" | "$sqlite_bin" "$em_db" 2>/dev/null | tr -d '[:space:]')
     if [ -n "$session_id" ] && [ -f "$HOME/.eagle-mem/.turn-counter.${session_id}" ]; then
         turns=$(tr -d '[:space:]' < "$HOME/.eagle-mem/.turn-counter.${session_id}" 2>/dev/null)
     else
@@ -57,5 +61,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)