eagle-mem 4.9.4 → 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,10 @@ Eagle Mem prevents Claude from repeating past mistakes:
 | `eagle-mem scan` | Scan codebase and generate overview |
 | `eagle-mem index` | Index source files for FTS5 code search |
 
+### v4.9.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.

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
 }

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/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.4",
+  "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

package/scripts/statusline-em.sh

@@ -12,6 +12,9 @@ eagle_mem_statusline() {
 
     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)"
@@ -24,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