eagle-mem 4.10.9 → 4.10.11

package/lib/provider.sh

@@ -152,6 +152,8 @@ eagle_config_init() {
 # Which LLM provider to use for the curator and analysis features
 # Options: "ollama" (free, local), "agent_cli" (Codex/Claude CLI auth), "anthropic", "openai"
 type = "$provider"
+# "auto" retries local/agent/API fallbacks when the primary provider fails.
+fallback = "auto"
 
 [ollama]
 url = "$ollama_url"
@@ -207,6 +209,12 @@ rtk = "auto"
 # "allow" keeps RTK advisory only.
 raw_bash = "block"
 
+[read_guard]
+# advisory = score repeated/expensive reads and nudge; block = deny high-score rereads.
+mode = "advisory"
+score_threshold = "70"
+block_threshold = "90"
+
 [redaction]
 # Additional secret patterns (regex) beyond built-in defaults
 # extra_patterns = ["MY_CUSTOM_SECRET_.*"]
@@ -223,14 +231,39 @@ eagle_llm_call() {
     local system_prompt="${2:-You are a helpful assistant that analyzes software development sessions.}"
     local max_tokens="${3:-1024}"
 
-    local provider
+    local provider chain candidate result rc tried=0
     provider=$(eagle_config_get "provider" "type" "none")
+    chain=$(_eagle_provider_chain "$provider")
+
+    if [ -z "$chain" ]; then
+        eagle_log "ERROR" "No LLM provider configured or available. Run: eagle-mem config"
+        return 1
+    fi
+
+    while IFS= read -r candidate; do
+        [ -z "$candidate" ] && continue
+        tried=$((tried + 1))
+        result=$(_eagle_call_provider_once "$candidate" "$prompt" "$system_prompt" "$max_tokens")
+        rc=$?
+        if [ "$rc" -eq 0 ] && [ -n "$result" ]; then
+            [ "$candidate" != "$provider" ] && eagle_log "INFO" "LLM provider fallback succeeded: primary=$provider used=$candidate"
+            printf '%s\n' "$result"
+            return 0
+        fi
+        eagle_log "WARN" "LLM provider candidate failed: primary=$provider candidate=$candidate rc=$rc"
+    done <<< "$chain"
+
+    eagle_log "ERROR" "All LLM provider candidates failed: primary=$provider tried=$tried"
+    return 1
+}
 
+_eagle_call_provider_once() {
+    local provider="$1" prompt="$2" system_prompt="$3" max_tokens="$4"
     case "$provider" in
-        ollama)   _eagle_call_ollama "$prompt" "$system_prompt" "$max_tokens" ;;
+        ollama)    _eagle_call_ollama "$prompt" "$system_prompt" "$max_tokens" ;;
         agent_cli) _eagle_call_agent_cli "$prompt" "$system_prompt" "$max_tokens" ;;
         anthropic) _eagle_call_anthropic "$prompt" "$system_prompt" "$max_tokens" ;;
-        openai)   _eagle_call_openai "$prompt" "$system_prompt" "$max_tokens" ;;
+        openai)    _eagle_call_openai "$prompt" "$system_prompt" "$max_tokens" ;;
         none)
             eagle_log "ERROR" "No LLM provider configured. Run: eagle-mem config"
             return 1
@@ -242,6 +275,79 @@ eagle_llm_call() {
     esac
 }
 
+_eagle_provider_chain() {
+    local primary="${1:-none}" fallback
+    fallback=$(eagle_config_get "provider" "fallback" "auto")
+
+    local chain=""
+    _eagle_provider_chain_add() {
+        local candidate="$1" required="${2:-available}"
+        [ -n "$candidate" ] || return 0
+        case " $chain " in *" $candidate "*) return 0 ;; esac
+        if [ "$required" = "available" ] && ! _eagle_provider_available "$candidate"; then
+            return 0
+        fi
+        chain="${chain}${chain:+ }$candidate"
+    }
+
+    if [ "$primary" != "none" ]; then
+        _eagle_provider_chain_add "$primary" "always"
+    fi
+
+    if [ "$fallback" != "off" ]; then
+        case "$primary" in
+            ollama)    _eagle_provider_chain_add "agent_cli"; _eagle_provider_chain_add "anthropic"; _eagle_provider_chain_add "openai" ;;
+            agent_cli) _eagle_provider_chain_add "ollama"; _eagle_provider_chain_add "anthropic"; _eagle_provider_chain_add "openai" ;;
+            anthropic) _eagle_provider_chain_add "ollama"; _eagle_provider_chain_add "agent_cli"; _eagle_provider_chain_add "openai" ;;
+            openai)    _eagle_provider_chain_add "ollama"; _eagle_provider_chain_add "agent_cli"; _eagle_provider_chain_add "anthropic" ;;
+            none|"")   _eagle_provider_chain_add "ollama"; _eagle_provider_chain_add "agent_cli"; _eagle_provider_chain_add "anthropic"; _eagle_provider_chain_add "openai" ;;
+        esac
+    fi
+
+    printf '%s\n' "$chain" | tr ' ' '\n' | sed '/^$/d'
+}
+
+_eagle_provider_available() {
+    case "$1" in
+        ollama)
+            [ -n "$(eagle_detect_ollama "$(eagle_config_get "ollama" "url" "$EAGLE_DEFAULT_OLLAMA_URL")" 2>/dev/null || true)" ]
+            ;;
+        agent_cli)
+            [ -n "$(_eagle_agent_cli_target_chain)" ]
+            ;;
+        anthropic)
+            [ -n "${ANTHROPIC_API_KEY:-}" ]
+            ;;
+        openai)
+            [ -n "${OPENAI_API_KEY:-}" ]
+            ;;
+        *) return 1 ;;
+    esac
+}
+
+_eagle_provider_model_label() {
+    case "$1" in
+        ollama)    printf 'ollama:%s' "$(eagle_config_get "ollama" "model" "mistral")" ;;
+        agent_cli) printf 'agent_cli:%s' "$(_eagle_agent_cli_target_summary)" ;;
+        anthropic) printf 'anthropic:%s' "$(eagle_config_get "anthropic" "model" "claude-haiku-4-5-20251001")" ;;
+        openai)    printf 'openai:%s' "$(eagle_config_get "openai" "model" "gpt-4o-mini")" ;;
+        *)         printf '%s' "$1" ;;
+    esac
+}
+
+eagle_llm_provider_label() {
+    local provider chain labels="" candidate sep=""
+    provider=$(eagle_config_get "provider" "type" "none")
+    chain=$(_eagle_provider_chain "$provider")
+    while IFS= read -r candidate; do
+        [ -z "$candidate" ] && continue
+        labels="${labels}${sep}$(_eagle_provider_model_label "$candidate")"
+        sep=" -> "
+    done <<< "$chain"
+    [ -n "$labels" ] || labels="none"
+    printf '%s\n' "$labels"
+}
+
 _eagle_call_ollama() {
     local prompt="$1" system="$2" max_tokens="$3"
     local url model
@@ -281,35 +387,57 @@ _eagle_call_ollama() {
 }
 
 _eagle_agent_cli_target() {
-    local preferred
+    local first
+    first=$(_eagle_agent_cli_target_chain | sed -n '1p')
+    if [ -n "$first" ]; then
+        printf '%s\n' "$first"
+    else
+        printf 'none\n'
+    fi
+}
+
+_eagle_agent_cli_target_chain() {
+    local preferred current preferred_target targets="" candidate
     preferred=$(eagle_config_get "agent_cli" "preferred" "current")
+    current=""
+    if [ -n "${EAGLE_AGENT_SOURCE:-${EAGLE_AGENT:-}}" ]; then
+        current=$(eagle_agent_source)
+    fi
 
     case "$preferred" in
-        codex|openai-codex) echo "codex"; return 0 ;;
-        claude|claude-code|cloud-code) echo "claude-code"; return 0 ;;
-        auto)
-            if [ -n "${EAGLE_AGENT_SOURCE:-${EAGLE_AGENT:-}}" ]; then
-                eagle_agent_source
-            elif command -v codex &>/dev/null; then
-                echo "codex"
-            elif command -v claude &>/dev/null; then
-                echo "claude-code"
-            else
-                echo "none"
-            fi
-            ;;
-        current|*)
-            if [ -n "${EAGLE_AGENT_SOURCE:-${EAGLE_AGENT:-}}" ]; then
-                eagle_agent_source
-            elif command -v codex &>/dev/null; then
-                echo "codex"
-            elif command -v claude &>/dev/null; then
-                echo "claude-code"
-            else
-                echo "none"
-            fi
-            ;;
+        codex|openai-codex) preferred_target="codex" ;;
+        claude|claude-code|cloud-code) preferred_target="claude-code" ;;
+        current) preferred_target="$current" ;;
+        auto|"") preferred_target="" ;;
+        *) preferred_target="$preferred" ;;
     esac
+
+    for candidate in "$preferred_target" "$current" codex claude-code; do
+        case "$candidate" in
+            codex|claude-code) ;;
+            *) continue ;;
+        esac
+        case "$candidate" in
+            codex) command -v codex >/dev/null 2>&1 || continue ;;
+            claude-code) command -v claude >/dev/null 2>&1 || continue ;;
+        esac
+        case " $targets " in *" $candidate "*) continue ;; esac
+        targets="${targets}${targets:+ }$candidate"
+    done
+
+    printf '%s\n' "$targets" | tr ' ' '\n' | sed '/^$/d'
+}
+
+_eagle_agent_cli_target_summary() {
+    local chain summary="" sep="" target
+    chain=$(_eagle_agent_cli_target_chain)
+    while IFS= read -r target; do
+        [ -z "$target" ] && continue
+        summary="${summary}${sep}${target}"
+        sep=" -> "
+    done <<< "$chain"
+    [ -n "$summary" ] || summary="none"
+    printf '%s\n' "$summary"
 }
 
 _eagle_agent_cli_prompt_file() {
@@ -327,17 +455,32 @@ _eagle_agent_cli_prompt_file() {
 
 _eagle_call_agent_cli() {
     local prompt="$1" system="$2" max_tokens="$3"
-    local target
-    target=$(_eagle_agent_cli_target)
+    local target targets result rc tried=0
+    targets=$(_eagle_agent_cli_target_chain)
 
-    case "$target" in
-        codex) _eagle_call_codex_cli "$prompt" "$system" "$max_tokens" ;;
-        claude-code) _eagle_call_claude_cli "$prompt" "$system" "$max_tokens" ;;
-        *)
-            eagle_log "ERROR" "agent_cli provider unavailable: no Codex or Claude CLI found"
-            return 1
-            ;;
-    esac
+    if [ -z "$targets" ]; then
+        eagle_log "ERROR" "agent_cli provider unavailable: no supported Codex or Claude CLI found"
+        return 1
+    fi
+
+    while IFS= read -r target; do
+        [ -z "$target" ] && continue
+        tried=$((tried + 1))
+        case "$target" in
+            codex) result=$(_eagle_call_codex_cli "$prompt" "$system" "$max_tokens"); rc=$? ;;
+            claude-code) result=$(_eagle_call_claude_cli "$prompt" "$system" "$max_tokens"); rc=$? ;;
+            *) rc=1; result="" ;;
+        esac
+        if [ "$rc" -eq 0 ] && [ -n "$result" ]; then
+            [ "$tried" -gt 1 ] && eagle_log "INFO" "agent_cli fallback succeeded with $target"
+            printf '%s\n' "$result"
+            return 0
+        fi
+        eagle_log "WARN" "agent_cli target failed: target=$target rc=$rc"
+    done <<< "$targets"
+
+    eagle_log "ERROR" "All agent_cli targets failed: targets=$(printf '%s' "$targets" | tr '\n' ',')"
+    return 1
 }
 
 _eagle_call_codex_cli() {
@@ -539,16 +682,19 @@ eagle_show_config() {
         return 1
     fi
 
-    local provider model
+    local provider model fallback
     provider=$(eagle_config_get "provider" "type" "none")
+    fallback=$(eagle_config_get "provider" "fallback" "auto")
     if [ "$provider" = "agent_cli" ]; then
-        model=$(_eagle_agent_cli_target)
+        model=$(_eagle_agent_cli_target_summary)
     else
         model=$(eagle_config_get "$provider" "model" "unknown")
     fi
 
     echo "Provider: $provider"
     echo "Model:    $model"
+    echo "Fallback: $fallback"
+    echo "Chain:    $(eagle_llm_provider_label)"
 
     if [ "$provider" = "ollama" ]; then
         local url
@@ -564,6 +710,7 @@ eagle_show_config() {
         fi
     elif [ "$provider" = "agent_cli" ]; then
         echo "Preferred: $(eagle_config_get "agent_cli" "preferred" "current")"
+        echo "Targets:   $(_eagle_agent_cli_target_summary)"
         echo "Codex:     $(command -v codex 2>/dev/null || echo "not found")"
         echo "Claude:    $(command -v claude 2>/dev/null || echo "not found")"
     fi

package/package.json

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

package/scripts/config.sh

@@ -36,6 +36,7 @@ show_help() {
     echo -e "    eagle-mem config set updates.allow patch"
     echo -e "    eagle-mem config set token_guard.rtk enforce"
     echo -e "    eagle-mem config set token_guard.raw_bash block"
+    echo -e "    eagle-mem config set read_guard.mode advisory"
     echo ""
     exit 0
 }
@@ -72,6 +73,7 @@ case "$subcommand" in
             eagle_info "  eagle-mem config set anthropic.model claude-haiku-4-5-20251001"
             eagle_info "  eagle-mem config set token_guard.rtk enforce"
             eagle_info "  eagle-mem config set token_guard.raw_bash block"
+            eagle_info "  eagle-mem config set read_guard.mode advisory"
             exit 1
         fi
         section="${key%%.*}"

package/scripts/curate.sh

@@ -37,6 +37,46 @@ Options:
 EOF
 }
 
+parse_consolidations_json() {
+    local result="$1"
+    local trimmed json_payload
+
+    trimmed=$(printf '%s' "$result" | tr -d '\r' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    case "$trimmed" in
+        ""|NONE|none|null)
+            printf '[]\n'
+            return 0
+            ;;
+    esac
+
+    json_payload=$(printf '%s' "$result" \
+        | sed -e '1s/^[[:space:]]*```json[[:space:]]*$//' \
+              -e '1s/^[[:space:]]*```[[:space:]]*$//' \
+              -e '$s/^[[:space:]]*```[[:space:]]*$//')
+
+    printf '%s' "$json_payload" | jq -c '
+        def trim: gsub("^\\s+|\\s+$"; "");
+        def names:
+            if type == "array" then map(tostring | trim) | map(select(length > 0))
+            elif type == "string" then split(",") | map(trim) | map(select(length > 0))
+            else []
+            end;
+        def root:
+            if type == "array" then .
+            elif type == "object" then (.consolidations // .items // .instructions // [])
+            else []
+            end;
+        root
+        | map({
+            source_names: ((.source_names // .sourceNames // .source_memories // .sourceMemories // .original_names // .originalNames // .originals // .names) | names),
+            new_name: ((.new_name // .newName // .name // .title // "") | tostring | trim),
+            description: ((.description // "") | tostring),
+            value: ((.value // .content // .compiled_truth // .compiledTruth // "") | tostring)
+        })
+        | map(select((.source_names | length) > 0 and (.new_name | length) > 0))
+    ' 2>/dev/null
+}
+
 while [ $# -gt 0 ]; do
     case "$1" in
         -h|--help)
@@ -60,19 +100,27 @@ fi
 
 p_esc=$(eagle_sql_escape "$project")
 
+cleanup_curate() {
+    local rc=$?
+    eagle_run_finish "$rc" "$LINENO"
+}
+eagle_run_start "curate" "$project" "$(pwd)"
+trap cleanup_curate EXIT
+
 # Verify provider is configured
 provider=$(eagle_config_get "provider" "type" "none")
 if [ "$provider" = "none" ]; then
     eagle_err "No LLM provider configured. Run: eagle-mem config init"
     exit 1
 fi
-eagle_info "Provider: $provider ($(eagle_config_get "$provider" "model" "unknown"))"
+eagle_info "Provider: $(eagle_llm_provider_label)"
 eagle_info "Project: $project"
 [ "$DRY_RUN" -eq 1 ] && eagle_info "Dry run — no changes will be made"
 echo ""
 
 # ─── 1. Analyze gotchas for promotion ─────────────────────
 
+eagle_run_step "promote_gotchas"
 eagle_info "Analyzing gotchas for promotion..."
 
 recent_gotchas=$(eagle_db "SELECT gotchas, created_at
@@ -559,7 +607,11 @@ if [ -n "$co_edit_data" ]; then
             co_wire_count=$((co_wire_count + 1))
         fi
     done <<< "$co_edit_data"
-    eagle_ok "Wired $co_wire_count co-edited file edges"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would wire $co_wire_count co-edited file edges"
+    else
+        eagle_ok "Wired $co_wire_count co-edited file edges"
+    fi
 fi
 
 # 7.2 Wire session nodes and access edges
@@ -569,35 +621,55 @@ if [ -n "$recent_sessions" ]; then
     if [ "$DRY_RUN" -eq 0 ]; then
         session_wire_count=$(eagle_graph_wire_recent_session_edges "$project" 15)
     fi
-    eagle_ok "Wired $session_wire_count recent session nodes and edges"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would wire $session_wire_count recent session nodes and edges"
+    else
+        eagle_ok "Wired $session_wire_count recent session nodes and edges"
+    fi
 fi
 
 # 7.3 Offline Memory Consolidation (Compiled Truth vs Evidence)
-active_memories=$(eagle_db "SELECT memory_name, memory_type, description, content FROM agent_memories WHERE project = '$p_esc';")
-if [ -n "$active_memories" ]; then
-    memory_node_count=0
-    active_memory_nodes=$(eagle_db_json "SELECT memory_name, content FROM agent_memories WHERE project = '$p_esc';" || true)
-    active_memory_node_count=$(printf '%s' "$active_memory_nodes" | jq 'length' 2>/dev/null || echo 0)
+active_memory_rows=$(eagle_db_json "SELECT memory_name, memory_type, description, content FROM agent_memories WHERE project = '$p_esc';" || {
+    eagle_log "WARN" "Unable to read active agent memories for consolidation"
+    echo "[]"
+})
+active_memory_count=$(printf '%s' "$active_memory_rows" | jq 'length' 2>/dev/null || echo 0)
+if [ "$active_memory_count" -gt 0 ]; then
+    wired_memory_count=0
     memory_node_index=0
-    while [ "$memory_node_index" -lt "$active_memory_node_count" ]; do
-        mname=$(printf '%s' "$active_memory_nodes" | jq -r ".[$memory_node_index].memory_name // empty")
-        mcontent=$(printf '%s' "$active_memory_nodes" | jq -r ".[$memory_node_index].content // empty")
+    while [ "$memory_node_index" -lt "$active_memory_count" ]; do
+        mname=$(printf '%s' "$active_memory_rows" | jq -r ".[$memory_node_index].memory_name // empty")
+        mcontent=$(printf '%s' "$active_memory_rows" | jq -r ".[$memory_node_index].content // empty")
         memory_node_index=$((memory_node_index + 1))
         [ -n "$mname" ] || continue
         if [ "$DRY_RUN" -eq 0 ]; then
             eagle_graph_add_node "$project" "memory" "$mname" "$mcontent" ""
         fi
-        memory_node_count=$((memory_node_count + 1))
+        wired_memory_count=$((wired_memory_count + 1))
     done
-    eagle_ok "Wired $memory_node_count agent memory graph nodes"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would wire $wired_memory_count agent memory graph nodes"
+    else
+        eagle_ok "Wired $wired_memory_count agent memory graph nodes"
+    fi
 
-    consolidation_prompt="Analyze these mirrored agent memories for project '$project'. Identify any memories that are redundant, overlap in scope, or describe the same subsystem/gotcha/concept.
-    
-MEMORIES:
-$active_memories
+    memory_prompt_json=$(printf '%s' "$active_memory_rows" | jq -c '[.[] | {
+        memory_name: .memory_name,
+        memory_type: .memory_type,
+        description: .description,
+        content: .content
+    }]')
 
-For any memories that should be consolidated, merge them into a single 'Compiled Truth' summary.
-The consolidated memory MUST be formatted exactly as:
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would analyze $wired_memory_count agent memories for consolidation"
+    else
+        consolidation_prompt="Analyze these mirrored agent memories for project '$project'. Identify memories that are redundant, overlap in scope, or describe the same subsystem/gotcha/concept.
+
+INPUT_MEMORIES_JSON:
+$memory_prompt_json
+
+For any memories that should be consolidated, merge them into a single Compiled Truth summary.
+The consolidated memory value MUST be formatted exactly as:
 --- Compiled Truth ---
 <A structured, clear, up-to-date summary of the topic, gotten by merging the duplicate/overlapping memories. Keep it extremely precise.>
 
@@ -605,55 +677,59 @@ The consolidated memory MUST be formatted exactly as:
 - <Original memory title 1>: <brief original description or timestamp>
 - <Original memory title 2>: <brief original description or timestamp>
 
-Format your output as a series of instructions:
-CONSOLIDATE: <original memory name 1>, <original memory name 2> -> <new consolidated memory name> | description: <new description> | value: <the merged compiled truth + evidence content>
+Return strict JSON only, with this schema:
+{
+  \"consolidations\": [
+    {
+      \"source_names\": [\"<exact source memory_name>\", \"<exact source memory_name>\"],
+      \"new_name\": \"<new consolidated memory name>\",
+      \"description\": \"<new description>\",
+      \"value\": \"<the merged compiled truth + evidence content>\"
+    }
+  ]
+}
 
-If no memories need consolidation, output: NONE"
+If no memories need consolidation, return {\"consolidations\":[]}."
 
-    consolidation_result=$(eagle_llm_call "$consolidation_prompt" "You consolidate software development memories into a single compiled truth. Be precise. Output CONSOLIDATE lines or NONE." 1024 || true)
+        consolidation_result=$(eagle_llm_call "$consolidation_prompt" "You consolidate software development memories into a single compiled truth. Return strict JSON only." 1024 || true)
+        if ! parsed_consolidations=$(parse_consolidations_json "$consolidation_result"); then
+            eagle_log "WARN" "Unable to parse memory consolidation provider response"
+            parsed_consolidations="[]"
+        fi
 
-    if [ -n "$consolidation_result" ] && ! echo "$consolidation_result" | grep -q "^NONE$"; then
-        cons_count=0
-        while IFS= read -r line; do
-            case "$line" in
-                CONSOLIDATE:*)
-                    cons_data=$(echo "$line" | sed 's/^CONSOLIDATE:[[:space:]]*//')
-                    
-                    # Parse matching: original_names -> new_name | description: desc | value: val
-                    names_part=$(echo "$cons_data" | cut -d'-' -f1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                    rest_part=$(echo "$cons_data" | cut -d'>' -f2-)
-                    new_name=$(echo "$rest_part" | cut -d'|' -f1 | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                    
-                    desc_part=$(echo "$rest_part" | grep -oE "description:[[:space:]]*[^|]+" | sed 's/description:[[:space:]]*//')
-                    val_part=$(echo "$rest_part" | grep -oE "value:[[:space:]]*.+" | sed 's/value:[[:space:]]*//')
-                    
-                    if [ -z "$new_name" ] || [ -z "$names_part" ]; then continue; fi
-                    
-                    if [ "$DRY_RUN" -eq 1 ]; then
-                        eagle_info "  Would consolidate: $names_part → $new_name"
+        consolidation_count=$(printf '%s' "$parsed_consolidations" | jq 'length' 2>/dev/null || echo 0)
+        if [ "$consolidation_count" -gt 0 ]; then
+            cons_count=0
+            consolidation_index=0
+            while [ "$consolidation_index" -lt "$consolidation_count" ]; do
+                consolidation_item=$(printf '%s' "$parsed_consolidations" | jq -c ".[$consolidation_index]")
+                consolidation_index=$((consolidation_index + 1))
+                new_name=$(printf '%s' "$consolidation_item" | jq -r '.new_name // empty')
+                val_part=$(printf '%s' "$consolidation_item" | jq -r '.value // empty')
+                [ -n "$new_name" ] || continue
+
+                eagle_graph_add_node "$project" "memory" "$new_name" "$val_part" ""
+                new_node_id=$(eagle_graph_get_node_id "$project" "memory" "$new_name")
+
+                old_count=$(printf '%s' "$consolidation_item" | jq '.source_names | length' 2>/dev/null || echo 0)
+                old_index=0
+                while [ "$old_index" -lt "$old_count" ]; do
+                    old_n=$(printf '%s' "$consolidation_item" | jq -r ".source_names[$old_index] // empty")
+                    old_index=$((old_index + 1))
+                    [ -n "$old_n" ] || continue
+                    old_node_id=$(eagle_graph_get_node_id "$project" "memory" "$old_n")
+                    if [ -n "$old_node_id" ] && [ -n "$new_node_id" ]; then
+                        eagle_graph_add_edge "$project" "$new_node_id" "$old_node_id" "supersedes" 1.0
                     else
-                        # 1. Add new consolidated memory node
-                        eagle_graph_add_node "$project" "memory" "$new_name" "$val_part" ""
-                        new_node_id=$(eagle_graph_get_node_id "$project" "memory" "$new_name")
-                        
-                        # 2. Wire supersedes edges from new node to old nodes, and mark old nodes as inactive/superseded
-                        IFS=',' read -ra name_arr <<< "$names_part"
-                        for old_n in "${name_arr[@]}"; do
-                            old_n=$(echo "$old_n" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                            if [ -z "$old_n" ]; then continue; fi
-                            old_node_id=$(eagle_graph_get_node_id "$project" "memory" "$old_n")
-                            if [ -n "$old_node_id" ] && [ -n "$new_node_id" ]; then
-                                eagle_graph_add_edge "$project" "$new_node_id" "$old_node_id" "supersedes" 1.0
-                            fi
-                        done
-                        cons_count=$((cons_count + 1))
+                        eagle_log "WARN" "Unable to wire supersedes edge: source='$old_n' consolidated='$new_name'"
                     fi
-                    ;;
-            esac
-        done <<< "$consolidation_result"
-        eagle_ok "Consolidated $cons_count sets of overlapping agent memories"
-    else
-        eagle_ok "Agent memories are fully consolidated and up to date"
+                done
+                cons_count=$((cons_count + 1))
+            done
+            eagle_ok "Consolidated $cons_count sets of overlapping agent memories"
+        else
+            eagle_ok "Agent memories are fully consolidated and up to date"
+        fi
     fi
 else
     eagle_dim "  No active agent memories to consolidate"

package/scripts/health.sh

@@ -136,14 +136,11 @@ max_score=$((max_score + 15))
 
 provider=$(eagle_config_get "provider" "type" "none")
 if [ "$provider" != "none" ]; then
-    if [ "$provider" = "agent_cli" ]; then
-        model=$(_eagle_agent_cli_target)
-    else
-        model=$(eagle_config_get "$provider" "model" "default")
-    fi
-    eagle_ok "Provider: ${provider} (${model})"
+    provider_chain=$(eagle_llm_provider_label)
+    eagle_ok "Provider: ${provider_chain}"
     score=$((score + 15))
 else
+    provider_chain="none"
     eagle_fail "No LLM provider — curator and enrichment disabled"
     issues+=("Configure a provider: eagle-mem config init")
 fi
@@ -321,6 +318,7 @@ if [ "$JSON_OUT" -eq 1 ]; then
         --argjson enriched_summaries "${enriched_summaries:-0}" \
         --argjson features "${feature_count:-0}" \
         --arg provider "$provider" \
+        --arg provider_chain "$provider_chain" \
         --arg token_guard_rtk "$rtk_mode" \
         --arg token_guard_raw_bash "$raw_bash_mode" \
         --arg rtk_bin "${rtk_bin:-}" \
@@ -345,7 +343,7 @@ if [ "$JSON_OUT" -eq 1 ]; then
         '{project:$project, score:$score, max:$max_score, pct:$pct, grade:$grade,
           capture:{sessions:$total_sessions, summaries:$total_summaries, heuristic:$heuristic_summaries},
           enrichment:$enriched_summaries,
-          features:$features, provider:$provider,
+          features:$features, provider:$provider, provider_chain:$provider_chain,
           token_guard:{rtk:$token_guard_rtk, raw_bash:$token_guard_raw_bash, rtk_bin:$rtk_bin},
           orchestration:{
             route:$orchestration_route,

package/scripts/help.sh

@@ -23,6 +23,7 @@ echo -e "    ${CYAN}uninstall${RESET}   Remove hooks and optionally delete data"
 echo -e "    ${CYAN}search${RESET}      Search past sessions, memories, and code"
 echo -e "    ${CYAN}health${RESET}      Diagnose pipeline health and background automation"
 echo -e "    ${CYAN}doctor${RESET}      Show install footprint, hooks, SQLite, manifest, and runtime drift"
+echo -e "    ${CYAN}logs${RESET}        Inspect command-scoped scan/index/curate logs"
 echo -e "    ${CYAN}updates${RESET}     Auto-update status and policy"
 echo -e "    ${CYAN}overview${RESET}    Build or view project overview"
 echo -e "    ${CYAN}session${RESET}     Save a manual session summary"