eagle-mem 4.10.9 → 4.10.11

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.10.11 Reliability Guards and Provider Fallback
+
+This patch closes the active reliability items that remained after the Dream Cycle hotfix:
+
+- **Command-Scoped Logs**: `scan`, `index`, and `curate` now write per-run logs under `~/.eagle-mem/runs`, preserve normal CLI output, and print the log path on command failure. Added `eagle-mem logs list|tail|show` for inspection.
+- **Provider Fallback Transparency**: Provider calls now use an explicit fallback chain. `agent_cli` can fall through from a failed preferred Codex call to Claude Code when available, and provider display now shows the actual chain instead of `unknown`.
+- **Read Prediction / Token Guard Scoring**: `PreToolUse` now scores repeated, large, or recently modified reads and emits a targeted read-score nudge. A configurable `read_guard.mode=block` path is available for stricter high-confidence duplicate-read gating.
+- **Auto-Scan Retry Reliability**: SessionStart auto-scan/index freshness markers are now cleared when the background job fails, so failed scans do not block retries for the next 24 hours.
+- **Hook Field Parsing**: Hook JSON field extraction now uses the intended unit separator in `PreToolUse`, `UserPromptSubmit`, and `Stop`, preserving clean `tool_name`, `session_id`, and `cwd` parsing.
+- **Regression Coverage**: Added an isolated reliability test for provider fallback, read scoring, auto-scan failure state cleanup, and run-log creation.
+
+---
+
+## v4.10.10 Dream Cycle Consolidation Hardening
+
+This patch closes the review findings from the multi-model Spectral pass:
+
+- **Structured Consolidation Parsing**: Dream Cycle memory consolidation now asks providers for strict JSON and validates the response with `jq`, removing the brittle `CONSOLIDATE:` text parser that could break on punctuation, arrows, pipes, or whitespace in memory names.
+- **Dry-Run Safety**: Memory graph consolidation dry-runs now preview graph wiring and skip the provider call, avoiding token spend and provider side effects during preview.
+- **Regression Coverage**: The Dream Cycle regression now covers JSON consolidation with punctuation-heavy names, `NONE` responses, malformed legacy text responses, idempotent reruns, and dry-run provider skipping.
+- **Indexer Edge Coverage**: Graph-memory indexing now verifies dot-command-like source lines, leading blank lines, all-whitespace chunks, and empty-file behavior.
+
+---
+
 ## v4.10.9 Dream Cycle Graph Memory Hotfix
 
 This hotfix closes the remaining graph-memory curation gap:

package/README.md

@@ -146,6 +146,7 @@ Eagle Mem prevents Claude from repeating past mistakes:
 | `eagle-mem search` | Search past sessions, memories, and code |
 | `eagle-mem health` | Diagnose pipeline health and background automation |
 | `eagle-mem doctor` | Verify installed runtime files, hooks, SQLite/FTS5, statusline, manifest, and drift |
+| `eagle-mem logs` | Inspect command-scoped `scan`, `index`, and `curate` run logs |
 | `eagle-mem config` | View or change LLM provider and token-guard settings |
 | `eagle-mem updates` | View or change auto-update policy |
 | `eagle-mem guard` | Manage regression guardrails for files |
@@ -184,7 +185,7 @@ eagle-mem overview set "Current project briefing..."
 
 If graph search shows stale deleted files, run `eagle-mem graph rebuild` from the project root. The rebuild command filters missing tracked paths, clears stale code chunks and declaration nodes, preserves manual overviews, and rewires declarations with file-scoped names such as `apps/mac/DictationController.swift::finishDictation`.
 
-Dream Cycle curation also wires mirrored agent memories into graph `memory` nodes before consolidation, so `supersedes` relationships stay attached to the source memories rather than to incidental text inside memory content.
+Dream Cycle curation also wires mirrored agent memories into graph `memory` nodes before consolidation, so `supersedes` relationships stay attached to the source memories rather than to incidental text inside memory content. Consolidation responses use a strict JSON contract, and dry-run previews skip the provider call for the memory-consolidation step.
 
 ### Trust and Recovery
 
@@ -346,6 +347,8 @@ eagle-mem config set agent_cli.preferred current
 
 Provider preference is local-first: Ollama is auto-detected when running, then Eagle Mem can use the installed Codex/Claude CLI via `agent_cli` before falling back to explicit Anthropic/OpenAI API providers. Eagle Mem works fully without a provider — LLM features gracefully degrade to heuristic fallbacks.
 
+Provider calls use an explicit fallback chain by default. For example, `agent_cli` can try the preferred/current agent first and then fall through to another supported local CLI when available. `eagle-mem config`, `eagle-mem health`, and `eagle-mem curate` display the resolved provider path so failed or unavailable agent CLIs are visible instead of appearing as `unknown`.
+
 RTK is configured separately from the LLM provider:
 
 ```bash
@@ -353,6 +356,8 @@ eagle-mem config set token_guard.rtk auto      # default: use RTK when available
 eagle-mem config set token_guard.rtk enforce   # block known raw-output commands if RTK is missing
 eagle-mem config set token_guard.rtk off       # disable RTK behavior
 eagle-mem config set token_guard.raw_bash block
+eagle-mem config set read_guard.mode advisory  # score repeated reads and nudge
+eagle-mem config set read_guard.mode block     # optionally block high-confidence duplicate reads
 ```
 
 ## Long-term Direction

package/bin/eagle-mem

@@ -22,6 +22,7 @@ case "$command" in
     search)     bash "$SCRIPTS_DIR/search.sh" "$@" ;;
     health)     bash "$SCRIPTS_DIR/health.sh" "$@" ;;
     doctor)     bash "$SCRIPTS_DIR/doctor.sh" "$PACKAGE_DIR" "$@" ;;
+    logs)       bash "$SCRIPTS_DIR/logs.sh" "$@" ;;
     config)     bash "$SCRIPTS_DIR/config.sh" "$@" ;;
     updates)    bash "$SCRIPTS_DIR/updates.sh" "$@" ;;
     statusline) "$SCRIPTS_DIR/statusline-em.sh" "$@" ;;

package/hooks/post-tool-use.sh

@@ -18,7 +18,7 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 IFS=$'\x1f' read -r session_id cwd tool_name hook_event <<< \
-    "$(echo "$input" | jq -r '[.session_id, .cwd, .tool_name, .hook_event_name] | map(. // "") | join("")')"
+    "$(echo "$input" | jq -r '[.session_id, .cwd, .tool_name, .hook_event_name] | map(. // "") | join("\u001f")')"
 agent=$(eagle_agent_source_from_json "$input")
 
 if [ -z "$session_id" ]; then exit 0; fi
@@ -173,12 +173,15 @@ if [ -n "$fp" ] && [ -n "$session_id" ] && eagle_validate_session_id "$session_i
             mod_dir="$EAGLE_MEM_DIR/mod-tracker"
             mkdir -p "$mod_dir" 2>/dev/null
             mod_file="$mod_dir/${session_id}"
-            echo "$fp" >> "$mod_file"
-            # Keep only last 3 entries — use per-process tmp to avoid
-            # race when parallel PostToolUse hooks fire on same session
-            if [ -f "$mod_file" ]; then
+            mod_lock="${mod_file}.lock"
+            if mkdir "$mod_lock" 2>/dev/null; then
                 _mod_tmp=$(mktemp "${mod_file}.XXXXXX" 2>/dev/null) || _mod_tmp="${mod_file}.$$"
-                tail -3 "$mod_file" > "$_mod_tmp" && mv "$_mod_tmp" "$mod_file" || rm -f "$_mod_tmp"
+                (cat "$mod_file" 2>/dev/null; printf '%s\n' "$fp") | tail -3 > "$_mod_tmp"
+                mv "$_mod_tmp" "$mod_file" 2>/dev/null || rm -f "$_mod_tmp"
+                rmdir "$mod_lock" 2>/dev/null || true
+            else
+                # If another hook is trimming, append is still safer than losing the edit.
+                printf '%s\n' "$fp" >> "$mod_file"
             fi
 
             # Full edit history for stuck loop detection (not truncated)

package/hooks/pre-tool-use.sh

@@ -22,7 +22,7 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 IFS=$'\x1f' read -r tool_name session_id cwd <<< \
-    "$(echo "$input" | jq -r '[.tool_name, .session_id, .cwd] | map(. // "") | join("")')"
+    "$(echo "$input" | jq -r '[.tool_name, .session_id, .cwd] | map(. // "") | join("\u001f")')"
 agent=$(eagle_agent_source_from_json "$input")
 
 case "$tool_name" in
@@ -295,11 +295,15 @@ Edit|Write|apply_patch)
 Read)
     fp=$(echo "$input" | jq -r '.tool_input.file_path // empty')
     if [ -n "$fp" ] && [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
+        read_score=0
+        read_reasons=""
 
         # ─── Read-after-modify detection ──────────────────────
         mod_file="$EAGLE_MEM_DIR/mod-tracker/${session_id}"
         if [ -f "$mod_file" ] && grep -qFx -- "$fp" "$mod_file" 2>/dev/null; then
             context+="Eagle Mem recall: '$(basename "$fp")' was just edited/written — the diff is already in context from the tool output. "
+            read_score=$((read_score + 45))
+            read_reasons="${read_reasons}recently modified; "
         fi
 
         # ─── Read dedup tracker (soft nudge) ──────────────────
@@ -312,6 +316,69 @@ Read)
         if [ "$read_count" -ge 3 ]; then
             context+="Eagle Mem recall: '$(basename "$fp")' has been read ${read_count} times this session. Its contents are likely already in context."
         fi
+
+        if [ "$read_count" -ge 2 ]; then
+            repeat_score=$((20 + (read_count - 2) * 10))
+            [ "$repeat_score" -gt 40 ] && repeat_score=40
+            read_score=$((read_score + repeat_score))
+            read_reasons="${read_reasons}${read_count} reads this session; "
+        fi
+
+        hot_files=$(eagle_get_hot_files "$project" 2>/dev/null || true)
+        if [ -n "$hot_files" ]; then
+            fp_base=$(basename "$fp")
+            case ",$hot_files," in
+                *"/$fp_base,"*|*",$fp_base,"*)
+                    read_score=$((read_score + 10))
+                    read_reasons="${read_reasons}hot file; "
+                    ;;
+            esac
+        fi
+
+        full_fp="$fp"
+        if [ ! -f "$full_fp" ] && [ -n "$cwd" ] && [ -f "$cwd/$fp" ]; then
+            full_fp="$cwd/$fp"
+        fi
+        if [ -f "$full_fp" ]; then
+            file_size=$(wc -c < "$full_fp" 2>/dev/null | tr -d ' ')
+            file_size=${file_size:-0}
+            if [ "$file_size" -ge 500000 ] 2>/dev/null; then
+                read_score=$((read_score + 20))
+                read_reasons="${read_reasons}large file; "
+            elif [ "$file_size" -ge 150000 ] 2>/dev/null; then
+                read_score=$((read_score + 10))
+                read_reasons="${read_reasons}medium-large file; "
+            fi
+        fi
+
+        [ "$read_score" -gt 100 ] && read_score=100
+        score_threshold=$(eagle_read_guard_score_threshold)
+        block_threshold=$(eagle_read_guard_block_threshold)
+        read_guard_mode=$(eagle_read_guard_mode)
+        read_reasons=${read_reasons%; }
+        if [ "$read_score" -ge "$score_threshold" ] 2>/dev/null; then
+            context+=" Eagle Mem read score: ${read_score}/100 for '$(basename "$fp")'"
+            [ -n "$read_reasons" ] && context+=" (${read_reasons})"
+            context+=". Prefer the existing context, recent diff, or targeted search unless you need exact fresh lines."
+        fi
+        if [ "$read_guard_mode" = "block" ] && [ "$read_score" -ge "$block_threshold" ] 2>/dev/null && ! eagle_raw_bash_unlock_active; then
+            reason="Eagle Mem blocked this high-confidence duplicate read to save context tokens.
+
+File: $(basename "$fp")
+Score: ${read_score}/100
+Reason: ${read_reasons:-repeated read}
+
+Use the existing context, run a narrower search, or bypass once with:
+  touch $EAGLE_RAW_BASH_UNLOCK"
+            jq -nc --arg reason "$reason" '{
+                "hookSpecificOutput":{
+                    "hookEventName":"PreToolUse",
+                    "permissionDecision":"deny",
+                    "permissionDecisionReason":$reason
+                }
+            }'
+            exit 0
+        fi
     fi
     ;;
 esac

package/hooks/stop.sh

@@ -22,7 +22,7 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 IFS=$'\x1f' read -r session_id cwd transcript_path agent_type <<< \
-    "$(echo "$input" | jq -r '[.session_id, .cwd, .transcript_path, .agent_type] | map(. // "") | join("")')"
+    "$(echo "$input" | jq -r '[.session_id, .cwd, .transcript_path, .agent_type] | map(. // "") | join("\u001f")')"
 last_assistant_message=$(echo "$input" | jq -r '.last_assistant_message // empty')
 agent=$(eagle_agent_source_from_json "$input")
 

package/hooks/user-prompt-submit.sh

@@ -19,7 +19,7 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 IFS=$'\x1f' read -r session_id cwd <<< \
-    "$(echo "$input" | jq -r '[.session_id, .cwd] | map(. // "") | join("")')"
+    "$(echo "$input" | jq -r '[.session_id, .cwd] | map(. // "") | join("\u001f")')"
 user_prompt=$(echo "$input" | jq -r '.prompt // empty')
 agent=$(eagle_agent_source_from_json "$input")
 

package/lib/common.sh

@@ -7,6 +7,7 @@
 EAGLE_MEM_DIR="${EAGLE_MEM_DIR:-$HOME/.eagle-mem}"
 EAGLE_MEM_DB="$EAGLE_MEM_DIR/memory.db"
 EAGLE_MEM_LOG="$EAGLE_MEM_DIR/eagle-mem.log"
+EAGLE_RUNS_DIR="${EAGLE_RUNS_DIR:-$EAGLE_MEM_DIR/runs}"
 EAGLE_SETTINGS="${EAGLE_SETTINGS:-$HOME/.claude/settings.json}"
 EAGLE_SKILLS_DIR="${EAGLE_SKILLS_DIR:-$HOME/.claude/skills}"
 EAGLE_CLAUDE_PROJECTS_DIR="${EAGLE_CLAUDE_PROJECTS_DIR:-$HOME/.claude/projects}"
@@ -112,6 +113,60 @@ eagle_log() {
     echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [$level] $*" >> "$EAGLE_MEM_LOG" 2>/dev/null || true
 }
 
+eagle_run_slug() {
+    printf '%s' "${1:-command}" \
+        | tr -c 'A-Za-z0-9._-' '-' \
+        | sed 's/^-*//;s/-*$//' \
+        | cut -c1-48
+}
+
+eagle_run_start() {
+    [ "${EAGLE_RUN_ACTIVE:-0}" = "1" ] && return 0
+
+    local command_name="$1" project="${2:-}" target="${3:-}"
+    local slug
+    slug=$(eagle_run_slug "$command_name")
+    [ -n "$slug" ] || slug="command"
+
+    mkdir -p "$EAGLE_RUNS_DIR" "$EAGLE_MEM_DIR" 2>/dev/null || true
+    EAGLE_RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)-${slug}-$$"
+    EAGLE_RUN_LOG="$EAGLE_RUNS_DIR/${EAGLE_RUN_ID}.log"
+    EAGLE_RUN_COMMAND="$command_name"
+    EAGLE_RUN_PROJECT="$project"
+    EAGLE_RUN_TARGET="$target"
+    EAGLE_RUN_ACTIVE=1
+    export EAGLE_RUN_ID EAGLE_RUN_LOG EAGLE_RUN_COMMAND EAGLE_RUN_PROJECT EAGLE_RUN_TARGET EAGLE_RUN_ACTIVE
+
+    touch "$EAGLE_RUN_LOG" 2>/dev/null && chmod 600 "$EAGLE_RUN_LOG" 2>/dev/null || true
+    {
+        printf '[%s] [INFO] run_start id=%s command=%s project=%s target=%s cwd=%s\n' \
+            "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$EAGLE_RUN_ID" "$command_name" "$project" "$target" "$(pwd)"
+    } >> "$EAGLE_RUN_LOG" 2>/dev/null || true
+
+    # Keep normal CLI output intact while also preserving a command-scoped log.
+    exec > >(tee -a "$EAGLE_RUN_LOG") 2> >(tee -a "$EAGLE_RUN_LOG" >&2)
+    eagle_log "INFO" "Run started: id=$EAGLE_RUN_ID command=$command_name project=$project log=$EAGLE_RUN_LOG"
+}
+
+eagle_run_step() {
+    [ "${EAGLE_RUN_ACTIVE:-0}" = "1" ] || return 0
+    printf '[%s] [STEP] %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$*" >> "$EAGLE_RUN_LOG" 2>/dev/null || true
+}
+
+eagle_run_finish() {
+    [ "${EAGLE_RUN_ACTIVE:-0}" = "1" ] || return 0
+    local rc="${1:-0}" line="${2:-unknown}"
+    printf '[%s] [INFO] run_finish id=%s rc=%s line=%s\n' \
+        "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$EAGLE_RUN_ID" "$rc" "$line" >> "$EAGLE_RUN_LOG" 2>/dev/null || true
+    if [ "$rc" -ne 0 ] 2>/dev/null; then
+        eagle_log "ERROR" "Run failed: id=$EAGLE_RUN_ID command=${EAGLE_RUN_COMMAND:-unknown} rc=$rc line=$line log=${EAGLE_RUN_LOG:-}"
+        printf '\nEagle Mem command failed: %s (exit %s, line %s)\nLog: %s\n' \
+            "${EAGLE_RUN_COMMAND:-unknown}" "$rc" "$line" "${EAGLE_RUN_LOG:-unknown}" >&2
+    else
+        eagle_log "INFO" "Run finished: id=$EAGLE_RUN_ID command=${EAGLE_RUN_COMMAND:-unknown} rc=0"
+    fi
+}
+
 eagle_normalize_project_path() {
     local path="${1:-$(pwd)}"
 
@@ -925,6 +980,36 @@ eagle_token_guard_raw_bash_mode() {
     fi
 }
 
+eagle_read_guard_mode() {
+    if declare -F eagle_config_get >/dev/null 2>&1; then
+        eagle_config_get "read_guard" "mode" "advisory"
+    else
+        eagle_config_get_light "read_guard" "mode" "advisory"
+    fi
+}
+
+eagle_read_guard_score_threshold() {
+    local threshold
+    if declare -F eagle_config_get >/dev/null 2>&1; then
+        threshold=$(eagle_config_get "read_guard" "score_threshold" "70")
+    else
+        threshold=$(eagle_config_get_light "read_guard" "score_threshold" "70")
+    fi
+    case "$threshold" in *[!0-9]*|"") threshold=70 ;; esac
+    printf '%s\n' "$threshold"
+}
+
+eagle_read_guard_block_threshold() {
+    local threshold
+    if declare -F eagle_config_get >/dev/null 2>&1; then
+        threshold=$(eagle_config_get "read_guard" "block_threshold" "90")
+    else
+        threshold=$(eagle_config_get_light "read_guard" "block_threshold" "90")
+    fi
+    case "$threshold" in *[!0-9]*|"") threshold=90 ;; esac
+    printf '%s\n' "$threshold"
+}
+
 eagle_raw_output_command_needs_guard() {
     local cmd="$1"
     local first

package/lib/hooks-sessionstart.sh

@@ -12,18 +12,23 @@ _eagle_state_slug() {
     printf '%s' "$1" | shasum | cut -c1-12
 }
 
+_eagle_state_file() {
+    local key="$1" project="$2"
+    local safe_project; safe_project=$(_eagle_state_slug "$project")
+    printf '%s/%s-%s\n' "$_state_dir" "$key" "$safe_project"
+}
+
 _eagle_state_fresh() {
     local key="$1" project="$2" max_age_days="${3:-1}"
-    local safe_project; safe_project=$(_eagle_state_slug "$project")
-    local state_file="$_state_dir/${key}-${safe_project}"
+    local state_file; state_file=$(_eagle_state_file "$key" "$project")
     [ -f "$state_file" ] && [ -z "$(find "$state_file" -mtime +${max_age_days} 2>/dev/null)" ]
 }
 
 _eagle_state_touch() {
     local key="$1" project="$2"
-    local safe_project; safe_project=$(_eagle_state_slug "$project")
+    local state_file; state_file=$(_eagle_state_file "$key" "$project")
     mkdir -p "$_state_dir" 2>/dev/null
-    touch "$_state_dir/${key}-${safe_project}"
+    touch "$state_file"
 }
 
 eagle_sessionstart_auto_provision() {
@@ -51,15 +56,63 @@ eagle_sessionstart_auto_provision() {
         eagle_log "INFO" "SessionStart: first-session provision — scan then index"
         _eagle_state_touch "scan" "$project"
         _eagle_state_touch "index" "$project"
-        nohup bash -c "bash '$scripts_dir/scan.sh' '$cwd' >> '$EAGLE_MEM_LOG' 2>&1; bash '$scripts_dir/index.sh' '$cwd' >> '$EAGLE_MEM_LOG' 2>&1" &
+        scan_state=$(_eagle_state_file "scan" "$project")
+        index_state=$(_eagle_state_file "index" "$project")
+        nohup bash -c '
+            scripts_dir="$1"; cwd="$2"; log="$3"; scan_state="$4"; index_state="$5"
+            bash "$scripts_dir/scan.sh" "$cwd" >> "$log" 2>&1
+            scan_rc=$?
+            if [ "$scan_rc" -eq 0 ]; then
+                touch "$scan_state" 2>/dev/null || true
+            else
+                rm -f "$scan_state" 2>/dev/null || true
+                printf "[%s] [ERROR] SessionStart: auto-scan failed rc=%s\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$scan_rc" >> "$log" 2>/dev/null || true
+            fi
+
+            bash "$scripts_dir/index.sh" "$cwd" >> "$log" 2>&1
+            index_rc=$?
+            if [ "$index_rc" -eq 0 ]; then
+                touch "$index_state" 2>/dev/null || true
+            else
+                rm -f "$index_state" 2>/dev/null || true
+                printf "[%s] [ERROR] SessionStart: auto-index failed rc=%s\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$index_rc" >> "$log" 2>/dev/null || true
+            fi
+
+            [ "$scan_rc" -eq 0 ] && exit "$index_rc"
+            exit "$scan_rc"
+        ' eagle-auto "$scripts_dir" "$cwd" "$EAGLE_MEM_LOG" "$scan_state" "$index_state" &
     elif [ "$needs_scan" = true ]; then
         eagle_log "INFO" "SessionStart: auto-scan triggered"
         _eagle_state_touch "scan" "$project"
-        nohup bash "$scripts_dir/scan.sh" "$cwd" >> "$EAGLE_MEM_LOG" 2>&1 &
+        scan_state=$(_eagle_state_file "scan" "$project")
+        nohup bash -c '
+            scripts_dir="$1"; cwd="$2"; log="$3"; scan_state="$4"
+            bash "$scripts_dir/scan.sh" "$cwd" >> "$log" 2>&1
+            rc=$?
+            if [ "$rc" -eq 0 ]; then
+                touch "$scan_state" 2>/dev/null || true
+            else
+                rm -f "$scan_state" 2>/dev/null || true
+                printf "[%s] [ERROR] SessionStart: auto-scan failed rc=%s\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$rc" >> "$log" 2>/dev/null || true
+            fi
+            exit "$rc"
+        ' eagle-auto "$scripts_dir" "$cwd" "$EAGLE_MEM_LOG" "$scan_state" &
     elif [ "$needs_index" = true ]; then
         eagle_log "INFO" "SessionStart: auto-index triggered"
         _eagle_state_touch "index" "$project"
-        nohup bash "$scripts_dir/index.sh" "$cwd" >> "$EAGLE_MEM_LOG" 2>&1 &
+        index_state=$(_eagle_state_file "index" "$project")
+        nohup bash -c '
+            scripts_dir="$1"; cwd="$2"; log="$3"; index_state="$4"
+            bash "$scripts_dir/index.sh" "$cwd" >> "$log" 2>&1
+            rc=$?
+            if [ "$rc" -eq 0 ]; then
+                touch "$index_state" 2>/dev/null || true
+            else
+                rm -f "$index_state" 2>/dev/null || true
+                printf "[%s] [ERROR] SessionStart: auto-index failed rc=%s\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$rc" >> "$log" 2>/dev/null || true
+            fi
+            exit "$rc"
+        ' eagle-auto "$scripts_dir" "$cwd" "$EAGLE_MEM_LOG" "$index_state" &
     fi
 }