eagle-mem 4.10.10 → 4.10.12

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.10.12 Spectral Review Closure
+
+This patch closes the multi-CLI Spectral review findings on v4.10.11:
+
+- **Run Log Containment**: `eagle-mem logs show|tail` now resolves only run-log IDs, filenames, or absolute paths under `~/.eagle-mem/runs`, preventing arbitrary file reads through the logs subcommand.
+- **Run Log Retention**: Added `eagle-mem logs prune --days N --keep N` plus automatic pruning when command-scoped run logs start, defaulting to logs older than 14 days and retaining the latest 50.
+- **Run Log Diagnostics**: `eagle_log` messages now mirror into the active command run log, so failure log paths include provider and internal diagnostic messages instead of only command stdout/stderr.
+- **PostToolUse Tracker Locking**: Modification tracking now writes every modified file through the same lock path, retries lock acquisition, avoids unlocked appends to the trimmed tracker, and records all files from multi-file `apply_patch` operations.
+- **Curator JSON Robustness**: Dream Cycle consolidation parsing now tolerates provider text wrapped around the JSON payload while preserving strict `jq` validation.
+- **Regression Coverage**: Expanded reliability tests for log path rejection, log pruning, mirrored run diagnostics, unsupported agent target logging, and multi-file modification tracking.
+
+---
+
+## 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:

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 and prune 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 |
@@ -346,6 +347,10 @@ 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`.
+
+Command-scoped run logs live under `~/.eagle-mem/runs`. Use `eagle-mem logs list`, `eagle-mem logs show <run-id>`, `eagle-mem logs tail <run-id>`, and `eagle-mem logs prune --days 14 --keep 50` to inspect or trim them. Log reads are constrained to the run-log directory.
+
 RTK is configured separately from the LLM provider:
 
 ```bash
@@ -353,6 +358,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

@@ -17,8 +17,52 @@ LIB_DIR="$SCRIPT_DIR/../lib"
 input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
+eagle_track_modified_path() {
+    local path="$1" sid="$2"
+    [ -n "$path" ] || return 0
+    [ -n "$sid" ] && eagle_validate_session_id "$sid" || return 0
+
+    local mod_dir mod_file mod_lock mod_tmp attempt
+    mod_dir="$EAGLE_MEM_DIR/mod-tracker"
+    mkdir -p "$mod_dir" 2>/dev/null || return 0
+    mod_file="$mod_dir/${sid}"
+    mod_lock="${mod_file}.lock"
+
+    for attempt in 1 2 3 4 5 6 7 8 9 10; do
+        if mkdir "$mod_lock" 2>/dev/null; then
+            mod_tmp=$(mktemp "${mod_file}.XXXXXX" 2>/dev/null) || mod_tmp="${mod_file}.$$"
+            (
+                cat "$mod_file" 2>/dev/null
+                for pending_file in "${mod_file}".pending.*; do
+                    [ -f "$pending_file" ] && cat "$pending_file" 2>/dev/null
+                done
+                printf '%s\n' "$path"
+            ) | tail -3 > "$mod_tmp"
+            mv "$mod_tmp" "$mod_file" 2>/dev/null || rm -f "$mod_tmp"
+            rm -f "${mod_file}".pending.* 2>/dev/null || true
+            rmdir "$mod_lock" 2>/dev/null || true
+            return 0
+        fi
+        sleep 0.05
+    done
+
+    printf '%s\n' "$path" >> "${mod_file}.pending.$$" 2>/dev/null || true
+    eagle_log "WARN" "PostToolUse: mod-tracker lock busy; queued pending modified file for session=$sid"
+}
+
+eagle_track_edit_history_path() {
+    local path="$1" sid="$2"
+    [ -n "$path" ] || return 0
+    [ -n "$sid" ] && eagle_validate_session_id "$sid" || return 0
+
+    local edit_dir
+    edit_dir="$EAGLE_MEM_DIR/edit-tracker"
+    mkdir -p "$edit_dir" 2>/dev/null || return 0
+    printf '%s\n' "$path" >> "$edit_dir/${sid}" 2>/dev/null || true
+}
+
 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
@@ -167,24 +211,16 @@ esac
 
 # ─── Track recent Edit/Write targets for Read-after-modify detection ──
 
-if [ -n "$fp" ] && [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
+if [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
     case "$tool_name" in
         Edit|Write|apply_patch)
-            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_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"
-            fi
-
-            # Full edit history for stuck loop detection (not truncated)
-            edit_dir="$EAGLE_MEM_DIR/edit-tracker"
-            mkdir -p "$edit_dir" 2>/dev/null
-            echo "$fp" >> "$edit_dir/${session_id}"
+            modified_paths=$(printf '%s' "$files_modified" | jq -r '.[]?' 2>/dev/null)
+            [ -n "$modified_paths" ] || modified_paths="$fp"
+            while IFS= read -r modified_path; do
+                [ -z "$modified_path" ] && continue
+                eagle_track_modified_path "$modified_path" "$session_id"
+                eagle_track_edit_history_path "$modified_path" "$session_id"
+            done <<< "$modified_paths"
             ;;
     esac
 fi

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}"
@@ -105,11 +106,105 @@ eagle_require_sqlite_fts5() {
 eagle_log() {
     local level="$1"
     shift
+    local ts msg
+    ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+    msg="[$ts] [$level] $*"
     # Ensure log file is owner-only (may contain debug data)
     if [ ! -f "$EAGLE_MEM_LOG" ]; then
         touch "$EAGLE_MEM_LOG" 2>/dev/null && chmod 600 "$EAGLE_MEM_LOG" 2>/dev/null
     fi
-    echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [$level] $*" >> "$EAGLE_MEM_LOG" 2>/dev/null || true
+    echo "$msg" >> "$EAGLE_MEM_LOG" 2>/dev/null || true
+    if [ "${EAGLE_RUN_ACTIVE:-0}" = "1" ] && [ -n "${EAGLE_RUN_LOG:-}" ] && [ "$EAGLE_RUN_LOG" != "$EAGLE_MEM_LOG" ]; then
+        echo "$msg" >> "$EAGLE_RUN_LOG" 2>/dev/null || true
+    fi
+}
+
+eagle_run_slug() {
+    printf '%s' "${1:-command}" \
+        | tr -c 'A-Za-z0-9._-' '-' \
+        | sed 's/^-*//;s/-*$//' \
+        | cut -c1-48
+}
+
+eagle_run_prune_logs() {
+    local days="${1:-${EAGLE_RUN_LOG_RETENTION_DAYS:-14}}"
+    local keep="${2:-${EAGLE_RUN_LOG_MAX_COUNT:-50}}"
+    local rel_log
+
+    [ -d "$EAGLE_RUNS_DIR" ] || return 0
+    case "$days" in ""|*[!0-9]*) days=14 ;; esac
+    case "$keep" in ""|*[!0-9]*) keep=50 ;; esac
+
+    find "$EAGLE_RUNS_DIR" -type f -name '*.log' -print 2>/dev/null \
+        | while IFS= read -r stale_log; do
+            rel_log="${stale_log#"$EAGLE_RUNS_DIR"/}"
+            case "$rel_log" in
+                */*) rm -f -- "$stale_log" 2>/dev/null || true ;;
+            esac
+        done
+
+    if [ "$days" -gt 0 ]; then
+        find "$EAGLE_RUNS_DIR" -type f -name '*.log' -mtime +"$days" -print 2>/dev/null \
+            | while IFS= read -r stale_log; do
+                rm -f -- "$stale_log" 2>/dev/null || true
+            done
+    fi
+
+    if [ "$keep" -gt 0 ]; then
+        ls -t "$EAGLE_RUNS_DIR"/*.log 2>/dev/null \
+            | awk -v keep="$keep" 'NR > keep' \
+            | while IFS= read -r stale_log; do
+                rm -f -- "$stale_log" 2>/dev/null || true
+            done
+    fi
+}
+
+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_prune_logs >/dev/null 2>&1 || 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() {
@@ -763,7 +858,9 @@ eagle_project_file_path() {
 }
 
 eagle_extract_apply_patch_files() {
-    sed -n -E 's/^\*\*\* (Add|Update|Delete) File: //p'
+    sed -n -E \
+        -e 's/^\*\*\* (Add|Update|Delete) File: //p' \
+        -e 's/^\*\*\* Move to: //p'
 }
 
 eagle_agent_source() {
@@ -925,6 +1022,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
 }