eagle-mem 4.10.13 → 4.11.0

package/scripts/repair.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Database Repair
+# Safe recovery workflow for malformed SQLite memory databases.
+# ═══════════════════════════════════════════════════════════
+set -euo pipefail
+
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
+PACKAGE_DIR="$(cd "$SCRIPTS_DIR/.." && pwd)"
+
+. "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
+
+json_output=false
+dry_run=true
+assume_yes=false
+backup_dir=""
+
+show_help() {
+    echo -e "  ${BOLD}eagle-mem repair${RESET} — Diagnose and recover a malformed memory database"
+    echo ""
+    echo -e "  ${BOLD}Usage:${RESET}"
+    echo -e "    eagle-mem repair                 ${DIM}# preview repair plan${RESET}"
+    echo -e "    eagle-mem repair ${CYAN}--dry-run${RESET}       ${DIM}# preview repair plan${RESET}"
+    echo -e "    eagle-mem repair ${CYAN}--yes${RESET}           ${DIM}# backup, recover, verify, replace${RESET}"
+    echo ""
+    echo -e "  ${BOLD}Options:${RESET}"
+    echo -e "    ${CYAN}--backup-dir${RESET} <path>  Backup directory (default: ~/.eagle-mem/backups)"
+    echo -e "    ${CYAN}-j, --json${RESET}           Output structured JSON"
+    echo ""
+    exit 0
+}
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --dry-run) dry_run=true; shift ;;
+        --yes|-y) assume_yes=true; dry_run=false; shift ;;
+        --backup-dir) backup_dir="$2"; shift 2 ;;
+        --json|-j) json_output=true; shift ;;
+        --help|-h) show_help ;;
+        *)
+            eagle_err "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+done
+
+[ -n "$backup_dir" ] || backup_dir="$EAGLE_MEM_DIR/backups"
+
+repair_json() {
+    local status="$1" message="$2" db_status="$3" db_detail="$4" backup_path="${5:-}" recovered_path="${6:-}"
+    jq -nc \
+        --arg status "$status" \
+        --arg command "repair" \
+        --arg message "$message" \
+        --arg db "$EAGLE_MEM_DB" \
+        --arg backup_dir "$backup_dir" \
+        --arg backup_path "$backup_path" \
+        --arg recovered_path "$recovered_path" \
+        --arg db_status "$db_status" \
+        --arg db_detail "$db_detail" \
+        '{status:$status, command:$command, message:$message, db:$db,
+          backup_dir:$backup_dir, backup_path:$backup_path, recovered_path:$recovered_path,
+          database:{integrity:{status:$db_status, detail:$db_detail}}}'
+}
+
+repair_emit() {
+    local status="$1" message="$2" db_status="$3" db_detail="$4" backup_path="${5:-}" recovered_path="${6:-}"
+    if [ "$json_output" = true ]; then
+        repair_json "$status" "$message" "$db_status" "$db_detail" "$backup_path" "$recovered_path"
+    else
+        case "$status" in
+            ok) eagle_ok "$message" ;;
+            repaired) eagle_ok "$message" ;;
+            needs_repair) eagle_warn "$message" ;;
+            *) eagle_fail "$message" ;;
+        esac
+        eagle_kv "Database:" "$EAGLE_MEM_DB"
+        eagle_kv "Integrity:" "$db_status"
+        [ -n "$db_detail" ] && eagle_dim "  $db_detail"
+        [ -n "$backup_path" ] && eagle_kv "Backup:" "$backup_path"
+        [ -n "$recovered_path" ] && eagle_kv "Recovered:" "$recovered_path"
+    fi
+}
+
+sqlite_bin=$(eagle_sqlite_path)
+if [ -z "$sqlite_bin" ]; then
+    repair_emit "error" "SQLite with FTS5 is unavailable." "unavailable" "sqlite3 with FTS5 not found"
+    exit 1
+fi
+
+if [ ! -f "$EAGLE_MEM_DB" ]; then
+    repair_emit "error" "Memory database file is missing." "missing" "database file not found"
+    exit 1
+fi
+
+integrity_check=$(eagle_db_integrity_status "$EAGLE_MEM_DB" 2>/dev/null || true)
+integrity_status="${integrity_check%%|*}"
+integrity_detail="${integrity_check#*|}"
+[ -n "$integrity_status" ] || integrity_status="unknown"
+[ -n "$integrity_detail" ] || integrity_detail="not checked"
+
+if [ "$integrity_status" = "ok" ]; then
+    repair_emit "ok" "Database integrity is already ok; no repair needed." "$integrity_status" "$integrity_detail"
+    exit 0
+fi
+
+if [ "$dry_run" = true ] || [ "$assume_yes" != true ]; then
+    repair_emit "needs_repair" "Database needs repair. Re-run with --yes to backup, recover, verify, and replace." "$integrity_status" "$integrity_detail"
+    exit 0
+fi
+
+timestamp=$(date -u +%Y%m%dT%H%M%SZ)
+mkdir -p "$backup_dir"
+backup_path="$backup_dir/memory-$timestamp.db"
+recover_dir=$(mktemp -d "$EAGLE_MEM_DIR/.repair.XXXXXX")
+recover_sql="$recover_dir/recover.sql"
+recovered_path="$recover_dir/memory.db"
+cleanup_repair() {
+    rm -rf "$recover_dir" 2>/dev/null || true
+}
+trap cleanup_repair EXIT
+
+cp "$EAGLE_MEM_DB" "$backup_path"
+chmod 600 "$backup_path" 2>/dev/null || true
+for suffix in -wal -shm; do
+    if [ -f "$EAGLE_MEM_DB$suffix" ]; then
+        cp "$EAGLE_MEM_DB$suffix" "$backup_path$suffix"
+        chmod 600 "$backup_path$suffix" 2>/dev/null || true
+    fi
+done
+
+set +e
+recover_output=$("$sqlite_bin" "$EAGLE_MEM_DB" ".recover" 2>&1 > "$recover_sql")
+recover_rc=$?
+set -e
+if [ "$recover_rc" -ne 0 ] || [ ! -s "$recover_sql" ]; then
+    repair_emit "error" "SQLite recovery failed; original database was left untouched." "$integrity_status" "${recover_output:-recover output was empty}" "$backup_path"
+    exit 1
+fi
+
+if ! "$sqlite_bin" "$recovered_path" < "$recover_sql" >/dev/null 2>"$recover_dir/import.err"; then
+    import_error=$(tr '\n' ' ' < "$recover_dir/import.err" | sed 's/[[:space:]][[:space:]]*/ /g')
+    repair_emit "error" "Recovered SQL could not be imported; original database was left untouched." "$integrity_status" "$import_error" "$backup_path"
+    exit 1
+fi
+
+core_tables=$("$sqlite_bin" "$recovered_path" "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name IN ('sessions','observations','summaries','agent_memories','agent_tasks');" 2>/dev/null || printf '0')
+if [ "${core_tables:-0}" -eq 0 ] 2>/dev/null; then
+    repair_emit "error" "Recovered SQL did not contain Eagle Mem core tables; original database was left untouched." "$integrity_status" "no recoverable Eagle Mem tables found" "$backup_path"
+    exit 1
+fi
+
+candidate_home="$recover_dir/home"
+mkdir -p "$candidate_home"
+mv "$recovered_path" "$candidate_home/memory.db"
+if ! EAGLE_MEM_DIR="$candidate_home" "$PACKAGE_DIR/db/migrate.sh" >/dev/null 2>"$recover_dir/migrate.err"; then
+    migrate_error=$(tr '\n' ' ' < "$recover_dir/migrate.err" | sed 's/[[:space:]][[:space:]]*/ /g')
+    repair_emit "error" "Recovered database migrations failed; original database was left untouched." "$integrity_status" "$migrate_error" "$backup_path"
+    exit 1
+fi
+recovered_path="$candidate_home/memory.db"
+
+post_check=$(eagle_db_integrity_status "$recovered_path" 2>/dev/null || true)
+post_status="${post_check%%|*}"
+post_detail="${post_check#*|}"
+if [ "$post_status" != "ok" ]; then
+    repair_emit "error" "Recovered database failed integrity check; original database was left untouched." "$post_status" "$post_detail" "$backup_path" "$recovered_path"
+    exit 1
+fi
+
+cp "$recovered_path" "$EAGLE_MEM_DB"
+chmod 600 "$EAGLE_MEM_DB" 2>/dev/null || true
+rm -f "$EAGLE_MEM_DB-wal" "$EAGLE_MEM_DB-shm" 2>/dev/null || true
+
+final_check=$(eagle_db_integrity_status "$EAGLE_MEM_DB" 2>/dev/null || true)
+final_status="${final_check%%|*}"
+final_detail="${final_check#*|}"
+if [ "$final_status" != "ok" ]; then
+    cp "$backup_path" "$EAGLE_MEM_DB"
+    chmod 600 "$EAGLE_MEM_DB" 2>/dev/null || true
+    repair_emit "error" "Replacement failed integrity check; backup was restored." "$final_status" "$final_detail" "$backup_path"
+    exit 1
+fi
+
+repair_emit "repaired" "Database repaired successfully." "$final_status" "$final_detail" "$backup_path" "$EAGLE_MEM_DB"

package/scripts/replay.sh

@@ -0,0 +1,248 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Replay
+# Shows prompt → recall → injected context summary → observed work for a session.
+# ═══════════════════════════════════════════════════════════
+set -euo pipefail
+
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
+
+. "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
+
+session_id=""
+project=""
+project_was_explicit=false
+cross_project=false
+json_output=false
+last=false
+
+show_help() {
+    echo -e "  ${BOLD}eagle-mem replay${RESET} — Replay what Eagle Mem did in a session"
+    echo ""
+    echo -e "  ${BOLD}Usage:${RESET}"
+    echo -e "    eagle-mem replay ${CYAN}<session-id>${RESET}"
+    echo -e "    eagle-mem replay ${CYAN}--last${RESET}"
+    echo -e "    eagle-mem replay ${CYAN}<session-id> --json${RESET}"
+    echo ""
+    echo -e "  ${BOLD}Options:${RESET}"
+    echo -e "    ${CYAN}-p, --project${RESET} <name>  Project name (default: current dir scope)"
+    echo -e "    ${CYAN}--all${RESET}                 Search all projects when resolving --last"
+    echo -e "    ${CYAN}--last${RESET}                Replay latest recall event session"
+    echo -e "    ${CYAN}-j, --json${RESET}            Output structured JSON"
+    echo ""
+    exit 0
+}
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --project|-p) project="$2"; project_was_explicit=true; shift 2 ;;
+        --all|-a) cross_project=true; shift ;;
+        --last) last=true; shift ;;
+        --json|-j) json_output=true; shift ;;
+        --help|-h) show_help ;;
+        -*)
+            eagle_err "Unknown option: $1"
+            exit 1
+            ;;
+        *)
+            session_id="$1"
+            shift
+            ;;
+    esac
+done
+
+replay_fail() {
+    local error_code="$1"
+    local message="$2"
+    local db_status="${3:-unknown}"
+    local db_detail="${4:-}"
+
+    if [ "$json_output" = true ]; then
+        jq -nc \
+            --arg status "error" \
+            --arg command "replay" \
+            --arg error "$error_code" \
+            --arg message "$message" \
+            --arg session_id "${session_id:-}" \
+            --arg project "${project:-}" \
+            --arg db_status "$db_status" \
+            --arg db_detail "$db_detail" \
+            '{status:$status, command:$command, error:$error, message:$message,
+              session_id:$session_id, project:$project,
+              database:{integrity:{status:$db_status, detail:$db_detail}}}'
+    else
+        eagle_err "$message"
+        [ -n "$db_detail" ] && eagle_dim "  $db_detail"
+    fi
+    exit 1
+}
+
+json_array_or_empty() {
+    local value="${1:-}"
+    if [ -z "$value" ] || ! printf '%s' "$value" | jq -e 'type == "array"' >/dev/null 2>&1; then
+        printf '[]\n'
+        return 0
+    fi
+    printf '%s\n' "$value"
+}
+
+if ! eagle_ensure_db; then
+    replay_fail "database_unavailable" "Database is unavailable; SQLite/FTS5 setup failed." "unavailable" "eagle_ensure_db failed"
+fi
+
+db_integrity_check=$(eagle_db_integrity_status "$EAGLE_MEM_DB" 2>/dev/null || true)
+db_integrity_status="${db_integrity_check%%|*}"
+db_integrity_detail="${db_integrity_check#*|}"
+[ -n "$db_integrity_status" ] || db_integrity_status="unknown"
+[ -n "$db_integrity_detail" ] || db_integrity_detail="not checked"
+if [ "$db_integrity_status" != "ok" ]; then
+    replay_fail "database_integrity" "Database integrity check failed; replay is unavailable." "$db_integrity_status" "$db_integrity_detail"
+fi
+
+if [ -z "$(eagle_db "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'recall_events' LIMIT 1;" 2>/dev/null || true)" ]; then
+    replay_fail "migration_missing" "Replay is unavailable until migrations create recall_events." "ok" "run: eagle-mem update"
+fi
+
+if [ -z "$project" ] && [ "$cross_project" = false ]; then
+    project=$(eagle_project_from_cwd "$(pwd)")
+fi
+if [ "$cross_project" = false ] && [ "$project_was_explicit" = false ]; then
+    project=$(eagle_recall_project_scope_from_cwd "$(pwd)" "$project")
+fi
+
+where_project="1 = 1"
+if [ "$cross_project" = false ]; then
+    where_project=$(eagle_sql_project_scope_condition "project" "$project")
+fi
+
+if [ -z "$session_id" ] || [ "$last" = true ]; then
+    session_id=$(eagle_db "SELECT session_id
+                           FROM recall_events
+                           WHERE $where_project
+                             AND session_id IS NOT NULL
+                             AND session_id != ''
+                           ORDER BY created_at DESC, id DESC
+                           LIMIT 1;" 2>/dev/null | awk 'NF { print; exit }')
+fi
+
+[ -n "$session_id" ] || replay_fail "session_missing" "No session id provided and no replayable recall event was found." "ok" "run: eagle-mem replay <session-id>"
+
+sid_sql=$(eagle_sql_escape "$session_id")
+
+session_json=$(eagle_db_json "SELECT id, project, agent, cwd, model, source, started_at, ended_at, status
+                              FROM sessions
+                              WHERE id = '$sid_sql'
+                              LIMIT 1;" 2>/dev/null || printf '[]')
+summary_json=$(eagle_db_json "SELECT request, completed, learned, decisions, gotchas, key_files, agent, created_at
+                              FROM summaries
+                              WHERE session_id = '$sid_sql'
+                              ORDER BY created_at DESC;" 2>/dev/null || printf '[]')
+recall_json=$(eagle_db_json "SELECT prompt_snippet, fts_query, summary_matches, memory_matches, code_matches,
+                                    summary_refs, memory_refs, code_refs, injected_token_estimate,
+                                    status, error, agent, created_at
+                             FROM recall_events
+                             WHERE session_id = '$sid_sql'
+                             ORDER BY created_at ASC, id ASC;" 2>/dev/null || printf '[]')
+observation_json=$(eagle_db_json "SELECT tool_name, tool_input_summary, files_read, files_modified, created_at
+                                  FROM observations
+                                  WHERE session_id = '$sid_sql'
+                                  ORDER BY created_at ASC
+                                  LIMIT 100;" 2>/dev/null || printf '[]')
+
+session_json=$(json_array_or_empty "$session_json")
+summary_json=$(json_array_or_empty "$summary_json")
+recall_json=$(json_array_or_empty "$recall_json")
+observation_json=$(json_array_or_empty "$observation_json")
+
+replay_json=$(jq -nc \
+    --arg status "ok" \
+    --arg command "replay" \
+    --arg session_id "$session_id" \
+    --arg db_integrity_status "$db_integrity_status" \
+    --arg db_integrity_detail "$db_integrity_detail" \
+    --argjson session "$session_json" \
+    --argjson summaries "$summary_json" \
+    --argjson recalls "$recall_json" \
+    --argjson observations "$observation_json" \
+    '{status:$status, command:$command, session_id:$session_id,
+      database:{integrity:{status:$db_integrity_status, detail:$db_integrity_detail}},
+      session:($session[0] // null),
+      summaries:$summaries,
+      recall_events:($recalls | map(
+        .summary_refs = ((.summary_refs // "[]") | fromjson? // []) |
+        .memory_refs = ((.memory_refs // "[]") | fromjson? // []) |
+        .code_refs = ((.code_refs // "[]") | fromjson? // [])
+      )),
+      observations:$observations}')
+
+if [ "$json_output" = true ]; then
+    printf '%s\n' "$replay_json"
+    exit 0
+fi
+
+eagle_header "Replay"
+eagle_info "Session: $session_id"
+project_label=$(printf '%s' "$replay_json" | jq -r '.session.project // empty')
+[ -n "$project_label" ] && eagle_info "Project: $project_label"
+echo ""
+
+recall_count=$(printf '%s' "$replay_json" | jq '.recall_events | length')
+summary_count=$(printf '%s' "$replay_json" | jq '.summaries | length')
+observation_count=$(printf '%s' "$replay_json" | jq '.observations | length')
+eagle_kv "Recall events:" "$recall_count"
+eagle_kv "Summaries:" "$summary_count"
+eagle_kv "Observations:" "$observation_count"
+echo ""
+
+printf '%s' "$replay_json" | jq -c '.recall_events[]' | while IFS= read -r event; do
+    created=$(printf '%s' "$event" | jq -r '.created_at // ""')
+    agent=$(printf '%s' "$event" | jq -r '.agent // ""')
+    prompt=$(printf '%s' "$event" | jq -r '.prompt_snippet // ""')
+    query=$(printf '%s' "$event" | jq -r '.fts_query // ""')
+    tokens=$(printf '%s' "$event" | jq -r '.injected_token_estimate // 0')
+    summaries=$(printf '%s' "$event" | jq -r '.summary_matches // 0')
+    memories=$(printf '%s' "$event" | jq -r '.memory_matches // 0')
+    code=$(printf '%s' "$event" | jq -r '.code_matches // 0')
+
+    echo -e "  ${BOLD}${created}${RESET}  ${DIM}$(eagle_agent_label "$agent")${RESET}"
+    [ -n "$prompt" ] && echo -e "  ${DIM}Prompt:${RESET} $prompt"
+    [ -n "$query" ] && echo -e "  ${DIM}Query:${RESET} $query"
+    echo -e "  ${DIM}Retrieved:${RESET} summaries=$summaries memories=$memories code=$code  ${DIM}Injected:${RESET} ~${tokens} tokens"
+
+    summary_refs=$(printf '%s' "$event" | jq -r '.summary_refs[]? | "- summary: " + ((.completed // .request // "summary") | tostring)' 2>/dev/null)
+    memory_refs=$(printf '%s' "$event" | jq -r '.memory_refs[]? | "- memory: " + ((.name // "memory") | tostring)' 2>/dev/null)
+    code_refs=$(printf '%s' "$event" | jq -r '.code_refs[]? | "- code: " + ((.file // "file") | tostring) + ":" + ((.start_line // "?") | tostring) + "-" + ((.end_line // "?") | tostring)' 2>/dev/null)
+
+    if [ -n "$summary_refs$memory_refs$code_refs" ]; then
+        echo -e "  ${DIM}Retrieved refs:${RESET}"
+        [ -n "$summary_refs" ] && printf '%s\n' "$summary_refs" | sed 's/^/    /'
+        [ -n "$memory_refs" ] && printf '%s\n' "$memory_refs" | sed 's/^/    /'
+        [ -n "$code_refs" ] && printf '%s\n' "$code_refs" | sed 's/^/    /'
+    fi
+    echo ""
+done
+
+if [ "$summary_count" -gt 0 ]; then
+    echo -e "  ${BOLD}Session summaries${RESET}"
+    printf '%s' "$replay_json" | jq -c '.summaries[]' | while IFS= read -r row; do
+        completed=$(printf '%s' "$row" | jq -r '.completed // ""')
+        learned=$(printf '%s' "$row" | jq -r '.learned // ""')
+        [ -n "$completed" ] && echo -e "  ${GREEN}Done:${RESET} $completed"
+        [ -n "$learned" ] && echo -e "  ${YELLOW}Learned:${RESET} $learned"
+    done
+    echo ""
+fi
+
+if [ "$observation_count" -gt 0 ]; then
+    echo -e "  ${BOLD}Observed tools${RESET}"
+    printf '%s' "$replay_json" | jq -c '.observations[-12:][]' | while IFS= read -r row; do
+        tool=$(printf '%s' "$row" | jq -r '.tool_name // ""')
+        detail=$(printf '%s' "$row" | jq -r '.tool_input_summary // ""')
+        created=$(printf '%s' "$row" | jq -r '.created_at // ""')
+        echo -e "  ${DIM}${created}${RESET} ${BOLD}${tool}:${RESET} $detail"
+    done
+    echo ""
+fi

package/scripts/search.sh

@@ -12,8 +12,6 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$LIB_DIR/common.sh"
 . "$LIB_DIR/db.sh"
 
-eagle_ensure_db
-
 # ─── Help ────────────────────────────────────────────────
 
 show_help() {
@@ -77,6 +75,44 @@ while [ $# -gt 0 ]; do
     esac
 done
 
+search_fail() {
+    local error_code="$1"
+    local message="$2"
+    local db_status="${3:-unknown}"
+    local db_detail="${4:-}"
+
+    if [ "$json_output" = true ]; then
+        jq -nc \
+            --arg status "error" \
+            --arg command "search" \
+            --arg mode "$mode" \
+            --arg error "$error_code" \
+            --arg message "$message" \
+            --arg project "${project:-}" \
+            --arg db_status "$db_status" \
+            --arg db_detail "$db_detail" \
+            '{status:$status, command:$command, mode:$mode, error:$error, message:$message,
+              project:$project, database:{integrity:{status:$db_status, detail:$db_detail}}}'
+    else
+        eagle_err "$message"
+        [ -n "$db_detail" ] && eagle_dim "  $db_detail"
+    fi
+    exit 1
+}
+
+if ! eagle_ensure_db; then
+    search_fail "database_unavailable" "Database is unavailable; SQLite/FTS5 setup failed." "unavailable" "eagle_ensure_db failed"
+fi
+
+db_integrity_check=$(eagle_db_integrity_status "$EAGLE_MEM_DB" 2>/dev/null || true)
+db_integrity_status="${db_integrity_check%%|*}"
+db_integrity_detail="${db_integrity_check#*|}"
+[ -n "$db_integrity_status" ] || db_integrity_status="unknown"
+[ -n "$db_integrity_detail" ] || db_integrity_detail="not checked"
+if [ "$db_integrity_status" != "ok" ]; then
+    search_fail "database_integrity" "Database integrity check failed; memory search is unavailable." "$db_integrity_status" "$db_integrity_detail"
+fi
+
 [ -z "$project" ] && project=$(eagle_project_from_cwd "$(pwd)")
 project_scope="$project"
 if [ "$cross_project" = false ] && [ "$project_was_explicit" = false ]; then
@@ -438,7 +474,12 @@ search_stats() {
             --argjson observations "${observations:-0}" \
             --argjson tasks "${tasks:-0}" \
             --argjson code_chunks "${chunks:-0}" \
-            '{project: $project, sessions: $sessions, sessions_claude: $sessions_claude, sessions_codex: $sessions_codex, summaries: $summaries, observations: $observations, tasks: $tasks, code_chunks: $code_chunks}'
+            --arg db_integrity_status "$db_integrity_status" \
+            --arg db_integrity_detail "$db_integrity_detail" \
+            '{status:"ok", project: $project,
+              database:{integrity:{status:$db_integrity_status, detail:$db_integrity_detail}},
+              sessions: $sessions, sessions_claude: $sessions_claude, sessions_codex: $sessions_codex,
+              summaries: $summaries, observations: $observations, tasks: $tasks, code_chunks: $code_chunks}'
         return
     fi
 

package/scripts/statusline-em.sh

@@ -41,10 +41,11 @@ eagle_mem_statusline_stats() {
     local session_id="${2:-}"
     local statusline_input="${3:-}"
     local current_dir="${4:-}"
-    local em_db="$HOME/.eagle-mem/memory.db"
+    local em_db="${EAGLE_MEM_DIR:-$HOME/.eagle-mem}/memory.db"
     [ -f "$em_db" ] || return
 
     _eagle_statusline_load_common
+    em_db="$EAGLE_MEM_DB"
 
     local sqlite_bin
     sqlite_bin=$(eagle_sqlite_path)
@@ -58,7 +59,7 @@ eagle_mem_statusline_stats() {
     [ -z "$project_dir" ] && project_dir="$(pwd)"
     [ -z "$current_dir" ] && current_dir="$project_dir"
 
-    local project_key project_scope project_condition stats sessions memories last_raw turns version latest
+    local project_key project_scope project_condition stats stats_rc sessions memories last_raw turns version latest db_status db_detail
     project_key=$(eagle_project_from_statusline_input "$statusline_input" "$project_dir" "$current_dir" "$session_id")
     [ -n "$project_key" ] || return
     project_scope=$(eagle_recall_project_scope_from_cwd "${current_dir:-$project_dir}" "$project_key")
@@ -70,6 +71,20 @@ eagle_mem_statusline_stats() {
         COALESCE(MAX(COALESCE(last_activity_at, started_at)), 'never')
         FROM sessions
         WHERE $project_condition;" 2>/dev/null)
+    stats_rc=$?
+    db_status="ok"
+    db_detail="ok"
+    if [ "$stats_rc" -ne 0 ] || [ -z "$stats" ]; then
+        local integrity_check
+        integrity_check=$(eagle_db_integrity_status "$em_db" 2>/dev/null || true)
+        db_status="${integrity_check%%|*}"
+        db_detail="${integrity_check#*|}"
+        [ -n "$db_status" ] || db_status="error"
+        [ -n "$db_detail" ] || db_detail="database query failed"
+        if [ "$db_status" != "ok" ]; then
+            stats="__DB_ERROR__|0|db_error"
+        fi
+    fi
     IFS='|' read -r sessions memories last_raw <<< "${stats:-0|0|never}"
     sessions=${sessions:-0}
     memories=${memories:-0}
@@ -92,15 +107,20 @@ eagle_mem_statusline_stats() {
     [ -z "$version" ] && version="?"
     [ -z "$latest" ] && latest="$version"
 
-    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$project_key" "$version" "$latest" "$sessions" "$memories" "$turns" "$last_raw"
+    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$project_key" "$version" "$latest" "$sessions" "$memories" "$turns" "$last_raw" "$db_status"
 }
 
 eagle_mem_statusline() {
-    local stats project_key version latest sessions memories turns last_raw
+    local stats project_key version latest sessions memories turns last_raw db_status
     stats=$(eagle_mem_statusline_stats "${1:-}" "${2:-}" "${3:-}" "${4:-}") || return
-    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw <<< "$stats"
+    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw db_status <<< "$stats"
 
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
+    if [ "${db_status:-ok}" != "ok" ]; then
+        printf "%bEagle%b %bv%s%b | %bDB error%b | turn %b%s%b" \
+            "$CYAN" "$R" "$WHT" "$version" "$DIM" "$WHT" "$DIM" "$WHT" "${turns:-0}" "$R"
+        return
+    fi
     printf "%bEagle%b %bv%s%b | %b%s%b sessions | %b%s%b memories | turn %b%s%b" \
         "$CYAN" "$R" \
         "$WHT" "$version" "$DIM" \
@@ -110,9 +130,9 @@ eagle_mem_statusline() {
 }
 
 eagle_mem_statusline_hud() {
-    local stats project_key version latest sessions memories turns last_raw last_label
+    local stats project_key version latest sessions memories turns last_raw last_label db_status
     stats=$(eagle_mem_statusline_stats "${1:-}" "${2:-}" "${3:-}" "${4:-}") || return
-    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw <<< "$stats"
+    IFS=$'\t' read -r project_key version latest sessions memories turns last_raw db_status <<< "$stats"
     last_label=$(_eagle_statusline_relative_time "$last_raw")
 
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'
@@ -136,6 +156,13 @@ eagle_mem_statusline_hud() {
         em_ver="${em_ver} ${GRN}✓${R}"
     fi
 
+    if [ "${db_status:-ok}" != "ok" ]; then
+        printf "%bEagle Mem%b %b %b│%b %bDatabase:%b %bERROR%b %b│%b %bTurns:%b %b%s/30%b %b(%s)%b" \
+            "$CYAN" "$R" "$em_ver" "$DIM" "$R" "$DIM" "$R" "$RED" "$R" "$DIM" "$R" \
+            "$DIM" "$R" "$turn_color" "$turns" "$R" "$turn_color" "$pressure_label" "$R"
+        return
+    fi
+
     printf "%bEagle Mem%b %b %b│%b %bSessions:%b %b%s%b %b│%b %bMemories:%b %b%s%b %b│%b %bTurns:%b %b%s/30%b %b(%s)%b %b│%b %bUpdated:%b %b%s%b" \
         "$CYAN" "$R" "$em_ver" \
         "$DIM" "$R" "$DIM" "$R" "$WHT" "${sessions:-0}" "$R" "$DIM" "$R" \

package/scripts/tasks.sh

@@ -71,6 +71,40 @@ project_sql=$(eagle_sql_escape "$project")
 [ -z "$agent" ] && agent=$(eagle_agent_source)
 agent_sql=$(eagle_sql_escape "$agent")
 
+tasks_fail() {
+    local error_code="$1"
+    local message="$2"
+    local db_status="${3:-unknown}"
+    local db_detail="${4:-}"
+
+    if [ "$json_output" = true ]; then
+        jq -nc \
+            --arg status "error" \
+            --arg command "tasks" \
+            --arg action "$action" \
+            --arg error "$error_code" \
+            --arg message "$message" \
+            --arg project "$project" \
+            --arg db_status "$db_status" \
+            --arg db_detail "$db_detail" \
+            '{status:$status, command:$command, action:$action, error:$error, message:$message,
+              project:$project, database:{integrity:{status:$db_status, detail:$db_detail}}}'
+    else
+        eagle_err "$message"
+        [ -n "$db_detail" ] && eagle_dim "  $db_detail"
+    fi
+    exit 1
+}
+
+db_integrity_check=$(eagle_db_integrity_status "$EAGLE_MEM_DB" 2>/dev/null || true)
+db_integrity_status="${db_integrity_check%%|*}"
+db_integrity_detail="${db_integrity_check#*|}"
+[ -n "$db_integrity_status" ] || db_integrity_status="unknown"
+[ -n "$db_integrity_detail" ] || db_integrity_detail="not checked"
+if [ "$db_integrity_status" != "ok" ]; then
+    tasks_fail "database_integrity" "Database integrity check failed; durable tasks are unavailable." "$db_integrity_status" "$db_integrity_detail"
+fi
+
 # ─── List tasks ───────────────────────────────────────────
 
 tasks_list() {

package/scripts/test.sh

@@ -55,6 +55,19 @@ run_check "Graph Memory Rebuild (isolated regression suite)" "bash \"$SCRIPTS_DI
 run_check "Dream Cycle Memory Graph Wiring (isolated regression suite)" "bash \"$SCRIPTS_DIR/../tests/test_curate_graph_memories.sh\""
 run_check "Reliability Guards (provider fallback, logs, autoscan, read scoring)" "bash \"$SCRIPTS_DIR/../tests/test_reliability_guards.sh\""
 run_check "Feature Verification Gate (monorepo path collisions)" "bash \"$SCRIPTS_DIR/../tests/test_feature_verification_gate.sh\""
+run_check "Compaction Survival Matrix (summary, memory, task, feature, recall, graph)" "bash \"$SCRIPTS_DIR/../tests/test_compaction_survival_matrix.sh\""
+run_check "Auto Orchestration Detection (broad prompt creates lanes/tasks)" "bash \"$SCRIPTS_DIR/../tests/test_auto_orchestration_detection.sh\""
+run_check "Agent Compatibility Docs Gate (official-doc verified hook contracts)" "bash \"$SCRIPTS_DIR/../tests/test_agent_compatibility_docs_gate.sh\""
+run_check "Claude Stop Hook Registration (bash wrapper)" "bash \"$SCRIPTS_DIR/../tests/test_claude_stop_hook_registration.sh\""
+run_check "Codex Hooks Config (canonical features.hooks flag)" "bash \"$SCRIPTS_DIR/../tests/test_codex_hooks_config.sh\""
+run_check "OpenCode Hooks Config (global plugin and skill registration)" "bash \"$SCRIPTS_DIR/../tests/test_opencode_hooks_config.sh\""
+run_check "OpenCode Plugin Adapter (hook normalization)" "bash \"$SCRIPTS_DIR/../tests/test_opencode_plugin_adapter.sh\""
+run_check "Rust Migration Plan (compatibility-first contract)" "bash \"$SCRIPTS_DIR/../tests/test_rust_migration_plan.sh\""
+run_check "Database Repair (safe preview and recovery failure path)" "bash \"$SCRIPTS_DIR/../tests/test_repair.sh\""
+run_check "Trust Surfaces (DB integrity, JSON errors, statusline)" "bash \"$SCRIPTS_DIR/../tests/test_trust_surfaces.sh\""
+run_check "Recall Observability (UserPromptSubmit recall event)" "bash \"$SCRIPTS_DIR/../tests/test_recall_observability.sh\""
+run_check "Eagle Event Log (hook/action observability)" "bash \"$SCRIPTS_DIR/../tests/test_eagle_events.sh\""
+run_check "Dashboard Surface (local HTML memory view)" "bash \"$SCRIPTS_DIR/../tests/test_dashboard.sh\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then