eagle-mem 4.10.9 → 4.10.11

package/scripts/index.sh

@@ -40,6 +40,15 @@ TARGET_DIR="${args[0]:-.}"
 TARGET_DIR="$(cd "$TARGET_DIR" && pwd)"
 PROJECT=$(eagle_project_from_cwd "$TARGET_DIR")
 
+TMPDIR_IDX=""
+cleanup_index() {
+    local rc=$?
+    [ -n "${TMPDIR_IDX:-}" ] && rm -rf "$TMPDIR_IDX" 2>/dev/null || true
+    eagle_run_finish "$rc" "$LINENO"
+}
+eagle_run_start "index" "$PROJECT" "$TARGET_DIR"
+trap cleanup_index EXIT
+
 CHUNK_SIZE="${EAGLE_MEM_CHUNK_SIZE:-80}"
 if ! [[ "$CHUNK_SIZE" =~ ^[0-9]+$ ]] || [ "$CHUNK_SIZE" -lt 1 ]; then
     CHUNK_SIZE=80
@@ -89,13 +98,32 @@ ext_to_lang() {
     esac
 }
 
+sql_literal_expr() {
+    awk '
+        BEGIN { first = 1 }
+        {
+            gsub(/\047/, "\047\047")
+            if (!first) {
+                printf "||char(10)||"
+            }
+            printf "\047%s\047", $0
+            first = 0
+        }
+        END {
+            if (first) {
+                printf "\047\047"
+            }
+        }
+    '
+}
+
 # ─── Collect files ─────────────────────────────────────────
 
 TMPDIR_IDX=$(mktemp -d)
-trap 'rm -rf "$TMPDIR_IDX"' EXIT
 
 ALL_FILES="$TMPDIR_IDX/all_files"
 
+eagle_run_step "collect_files"
 eagle_collect_files "$TARGET_DIR" "$ALL_FILES"
 
 # Filter to source files only, skip large files
@@ -128,6 +156,7 @@ NEEDS_INDEX="$TMPDIR_IDX/needs_index"
 skipped_count=0
 
 if [ "$force" = true ]; then
+    eagle_run_step "force_clear_index_state"
     eagle_info "Force rebuild requested: clearing chunks, declarations, and import edges"
     eagle_graph_clear_index_state "$PROJECT"
 fi
@@ -164,6 +193,7 @@ if [ "$needs_count" -eq 0 ]; then
 fi
 
 eagle_info "$needs_count files to index"
+eagle_run_step "index_files count=$needs_count"
 
 # ─── Chunk and index files ─────────────────────────────────
 
@@ -194,11 +224,11 @@ DELETE FROM code_chunks WHERE project = '$project_sql' AND file_path = '$file_sq
         [ "$end" -gt "$total_lines" ] && end="$total_lines"
 
         content=$(sed -n "${start},${end}p" "$full_path" | eagle_redact)
-        content_sql=$(eagle_sql_escape "$content")
+        content_expr=$(printf '%s\n' "$content" | sql_literal_expr)
 
         txn_sql+="
 INSERT INTO code_chunks (project, file_path, language, start_line, end_line, content, mtime)
-VALUES ('$project_sql', '$file_sql', '$lang_sql', $start, $end, '$content_sql', $current_mtime);"
+VALUES ('$project_sql', '$file_sql', '$lang_sql', $start, $end, $content_expr, $current_mtime);"
 
         chunk_count=$((chunk_count + 1))
         start=$((end + 1))

package/scripts/logs.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Command Run Logs
+# ═══════════════════════════════════════════════════════════
+set -euo pipefail
+
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
+
+. "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
+
+cmd="${1:-list}"
+[ $# -gt 0 ] && shift || true
+
+show_help() {
+    cat <<EOF
+Usage: eagle-mem logs [list|tail|show] [run-id-or-path]
+
+Commands:
+  list              Show recent command-scoped run logs
+  tail [id|path]    Tail a run log, or the latest run log when omitted
+  show <id|path>    Print a run log
+EOF
+}
+
+resolve_log_path() {
+    local ref="${1:-}"
+    if [ -z "$ref" ]; then
+        ls -t "$EAGLE_RUNS_DIR"/*.log 2>/dev/null | sed -n '1p'
+        return 0
+    fi
+    if [ -f "$ref" ]; then
+        printf '%s\n' "$ref"
+        return 0
+    fi
+    if [ -f "$EAGLE_RUNS_DIR/$ref" ]; then
+        printf '%s\n' "$EAGLE_RUNS_DIR/$ref"
+        return 0
+    fi
+    if [ -f "$EAGLE_RUNS_DIR/$ref.log" ]; then
+        printf '%s\n' "$EAGLE_RUNS_DIR/$ref.log"
+        return 0
+    fi
+    return 1
+}
+
+case "$cmd" in
+    -h|--help|help)
+        show_help
+        ;;
+    list)
+        eagle_header "Run Logs"
+        if ! ls "$EAGLE_RUNS_DIR"/*.log >/dev/null 2>&1; then
+            eagle_info "No run logs found yet"
+            eagle_dim "Run eagle-mem scan, index, or curate to create command-scoped logs."
+            exit 0
+        fi
+        ls -t "$EAGLE_RUNS_DIR"/*.log 2>/dev/null | head -20 | while IFS= read -r log_path; do
+            first_line=$(sed -n '1p' "$log_path" 2>/dev/null)
+            run_id=$(basename "$log_path" .log)
+            printf '  %s  %s\n' "$run_id" "$first_line"
+        done
+        ;;
+    tail)
+        log_path=$(resolve_log_path "${1:-}") || {
+            eagle_err "Run log not found"
+            exit 1
+        }
+        tail -n "${EAGLE_LOG_TAIL_LINES:-80}" "$log_path"
+        ;;
+    show)
+        log_path=$(resolve_log_path "${1:-}") || {
+            eagle_err "Run log not found"
+            exit 1
+        }
+        cat "$log_path"
+        ;;
+    *)
+        eagle_err "Unknown logs command: $cmd"
+        show_help
+        exit 1
+        ;;
+esac

package/scripts/scan.sh

@@ -29,6 +29,15 @@ TARGET_DIR="${args[0]:-.}"
 TARGET_DIR="$(cd "$TARGET_DIR" && pwd)"
 PROJECT=$(eagle_project_from_cwd "$TARGET_DIR")
 
+TMPFILE=""
+cleanup_scan() {
+    local rc=$?
+    [ -n "${TMPFILE:-}" ] && rm -f "$TMPFILE" "${TMPFILE}.analysis" 2>/dev/null || true
+    eagle_run_finish "$rc" "$LINENO"
+}
+eagle_run_start "scan" "$PROJECT" "$TARGET_DIR"
+trap cleanup_scan EXIT
+
 eagle_header "Scan"
 eagle_info "Scanning ${BOLD}$PROJECT${RESET} at $TARGET_DIR"
 echo ""
@@ -52,8 +61,8 @@ if git -C "$TARGET_DIR" rev-parse --is-inside-work-tree &>/dev/null; then
 fi
 
 TMPFILE=$(mktemp)
-trap 'rm -f "$TMPFILE"' EXIT
 
+eagle_run_step "collect_files"
 eagle_collect_files "$TARGET_DIR" "$TMPFILE"
 
 total_files=$(wc -l < "$TMPFILE" | tr -d ' ')
@@ -67,6 +76,7 @@ eagle_ok "$total_files files found"
 
 # ─── Language breakdown (bash 3 compatible — no assoc arrays) ──
 
+eagle_run_step "language_breakdown"
 while IFS= read -r file; do
     ext="${file##*.}"
     [ "$ext" = "$file" ] && continue

package/scripts/test.sh

@@ -53,6 +53,7 @@ run_check "Installer And Updater (install / update syntax)" "bash -n \"$SCRIPTS_
 run_check "Code Scan And Index (scan / index syntax)" "bash -n \"$SCRIPTS_DIR/scan.sh\" && bash -n \"$SCRIPTS_DIR/index.sh\""
 run_check "Graph Memory Rebuild (isolated regression suite)" "bash \"$SCRIPTS_DIR/../tests/test_graph_memory.sh\""
 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\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then

package/tests/test_curate_graph_memories.sh

@@ -14,24 +14,12 @@ mkdir -p "$HOME" "$EAGLE_MEM_DIR" "$tmp_dir/bin"
 
 cat > "$tmp_dir/bin/curl" <<'EOF'
 #!/usr/bin/env bash
-body=""
-while [ "$#" -gt 0 ]; do
-    case "$1" in
-        -d)
-            shift
-            body="${1:-}"
-            ;;
-    esac
-    shift || true
-done
-
-if printf '%s' "$body" | grep -q "mirrored agent memories"; then
-    content="CONSOLIDATE: Memory A, Memory B -> Compiled AB | description: merged memories | value: --- Compiled Truth --- merged truth"
-else
-    content="NONE"
+if [ -n "${EAGLE_CURATE_FAKE_CURL_MARKER:-}" ]; then
+    echo called >> "$EAGLE_CURATE_FAKE_CURL_MARKER"
 fi
 
-jq -nc --arg content "$content" '{message:{content:$content}}'
+content="${EAGLE_CURATE_FAKE_RESPONSE:-NONE}"
+jq -nc --arg content "$content" '{message:{role:"assistant",content:$content}}'
 EOF
 chmod +x "$tmp_dir/bin/curl"
 export PATH="$tmp_dir/bin:$PATH"
@@ -49,45 +37,104 @@ url = "http://127.0.0.1:11434"
 model = "fake"
 EOF
 
-eagle_db "INSERT INTO agent_memories (project, file_path, memory_name, memory_type, description, content)
-          VALUES
-          ('project', 'memory://a', 'Memory A', 'project', 'First memory', 'Content A
-Evidence line that must not become a graph node'),
-          ('project', 'memory://b', 'Memory B', 'project', 'Second memory', 'Content B');" >/dev/null
-
-"$EAGLE_BIN" curate -p project >/dev/null
-
-original_count=$(eagle_db "SELECT COUNT(*)
-                          FROM graph_nodes
-                          WHERE project = 'project'
-                            AND node_type = 'memory'
-                            AND node_name IN ('Memory A', 'Memory B');")
-if [ "$original_count" != "2" ]; then
-    echo "expected original agent memories to be graph nodes, got $original_count" >&2
-    exit 1
-fi
+assert_eq() {
+    local expected="$1" actual="$2" message="$3"
+    if [ "$actual" != "$expected" ]; then
+        echo "$message: expected $expected, got $actual" >&2
+        exit 1
+    fi
+}
+
+insert_memory() {
+    local project="$1" file_path="$2" memory_name="$3" description="$4" content="$5"
+    eagle_db "INSERT INTO agent_memories (project, file_path, memory_name, memory_type, description, content)
+              VALUES
+              ('$(eagle_sql_escape "$project")',
+               '$(eagle_sql_escape "$file_path")',
+               '$(eagle_sql_escape "$memory_name")',
+               'project',
+               '$(eagle_sql_escape "$description")',
+               '$(eagle_sql_escape "$content")');" >/dev/null
+}
+
+agent_memory_rows() {
+    local project="$1"
+    eagle_db "SELECT COUNT(*)
+              FROM agent_memories
+              WHERE project = '$(eagle_sql_escape "$project")';"
+}
+
+memory_graph_nodes() {
+    local project="$1"
+    eagle_db "SELECT COUNT(*)
+              FROM graph_nodes
+              WHERE project = '$(eagle_sql_escape "$project")'
+                AND node_type = 'memory';"
+}
+
+supersedes_edges() {
+    local project="$1" new_name="${2:-}"
+    local new_filter=""
+    if [ -n "$new_name" ]; then
+        new_filter="AND s.node_name = '$(eagle_sql_escape "$new_name")'"
+    fi
+    eagle_db "SELECT COUNT(*)
+              FROM graph_edges e
+              JOIN graph_nodes s ON s.id = e.source_node_id
+              JOIN graph_nodes t ON t.id = e.target_node_id
+              WHERE e.project = '$(eagle_sql_escape "$project")'
+                AND e.edge_type = 'supersedes'
+                AND s.node_type = 'memory'
+                AND t.node_type = 'memory'
+                $new_filter;"
+}
 
-memory_node_count=$(eagle_db "SELECT COUNT(*)
-                             FROM graph_nodes
-                             WHERE project = 'project'
-                               AND node_type = 'memory';")
-if [ "$memory_node_count" != "3" ]; then
-    echo "expected two originals plus one consolidated memory node, got $memory_node_count" >&2
+# Happy path: structured JSON survives punctuation that broke the old text parser.
+export EAGLE_CURATE_FAKE_RESPONSE='{"consolidations":[{"source_names":["Memory A - Dash","Memory B > Pipe | Name"],"new_name":"Compiled AB JSON","description":"merged memories","value":"--- Compiled Truth ---\nmerged truth\n\n--- Evidence Trail ---\n- Memory A - Dash\n- Memory B > Pipe | Name"}]}'
+insert_memory "project-json" "memory://a" "Memory A - Dash" "First memory" $'Content A\nEvidence line that must not become a graph node'
+insert_memory "project-json" "memory://b" "Memory B > Pipe | Name" "Second memory" "Content B"
+
+"$EAGLE_BIN" curate -p project-json >/dev/null
+assert_eq "2" "$(agent_memory_rows project-json)" "source agent memories should survive curate"
+assert_eq "3" "$(memory_graph_nodes project-json)" "curate should create two originals plus one consolidated memory node"
+assert_eq "2" "$(supersedes_edges project-json "Compiled AB JSON")" "consolidated memory should supersede both originals"
+
+# Idempotency: re-running the same consolidation should not create duplicate nodes or edges.
+"$EAGLE_BIN" curate -p project-json >/dev/null
+assert_eq "3" "$(memory_graph_nodes project-json)" "curate should keep memory graph nodes idempotent"
+assert_eq "2" "$(supersedes_edges project-json "Compiled AB JSON")" "curate should keep supersedes edge count idempotent"
+
+# No consolidation: source nodes are still wired, but no supersedes edges are created.
+export EAGLE_CURATE_FAKE_RESPONSE='{"consolidations":[]}'
+insert_memory "project-none" "memory://none-a" "Memory None A" "First none memory" "Content A"
+insert_memory "project-none" "memory://none-b" "Memory None B" "Second none memory" "Content B"
+"$EAGLE_BIN" curate -p project-none >/dev/null
+assert_eq "2" "$(memory_graph_nodes project-none)" "NONE response should still wire source memory nodes"
+assert_eq "0" "$(supersedes_edges project-none)" "NONE response should not create supersedes edges"
+
+# Malformed legacy/text output is ignored safely instead of producing partial graph edges.
+export EAGLE_CURATE_FAKE_RESPONSE='CONSOLIDATE: Memory Broken A, Memory Broken B -> Broken AB | description: legacy | value: legacy text'
+insert_memory "project-malformed" "memory://bad-a" "Memory Broken A" "First malformed memory" "Content A"
+insert_memory "project-malformed" "memory://bad-b" "Memory Broken B" "Second malformed memory" "Content B"
+"$EAGLE_BIN" curate -p project-malformed >/dev/null
+assert_eq "2" "$(memory_graph_nodes project-malformed)" "malformed response should still wire source memory nodes"
+assert_eq "0" "$(supersedes_edges project-malformed)" "malformed response should not create supersedes edges"
+
+# Dry-run: memory graph writes and provider calls are skipped for consolidation.
+dry_run_marker="$tmp_dir/curl-called"
+dry_run_output="$tmp_dir/dry-run.out"
+export EAGLE_CURATE_FAKE_CURL_MARKER="$dry_run_marker"
+export EAGLE_CURATE_FAKE_RESPONSE='{"consolidations":[{"source_names":["Dry A","Dry B"],"new_name":"Dry AB","description":"dry","value":"dry"}]}'
+insert_memory "project-dry" "memory://dry-a" "Dry A" "First dry memory" "Content A"
+insert_memory "project-dry" "memory://dry-b" "Dry B" "Second dry memory" "Content B"
+"$EAGLE_BIN" curate --dry-run -p project-dry > "$dry_run_output"
+if [ -f "$dry_run_marker" ]; then
+    echo "dry-run should not call the consolidation provider" >&2
     exit 1
 fi
-
-supersedes_edges=$(eagle_db "SELECT COUNT(*)
-                            FROM graph_edges e
-                            JOIN graph_nodes s ON s.id = e.source_node_id
-                            JOIN graph_nodes t ON t.id = e.target_node_id
-                            WHERE e.project = 'project'
-                              AND e.edge_type = 'supersedes'
-                              AND s.node_type = 'memory'
-                              AND s.node_name = 'Compiled AB'
-                              AND t.node_type = 'memory'
-                              AND t.node_name IN ('Memory A', 'Memory B');")
-if [ "$supersedes_edges" != "2" ]; then
-    echo "expected consolidated memory to supersede both originals, got $supersedes_edges" >&2
+assert_eq "0" "$(memory_graph_nodes project-dry)" "dry-run should not write memory graph nodes"
+if ! grep -q "Would wire 2 agent memory graph nodes" "$dry_run_output"; then
+    echo "dry-run did not report the memory graph wiring preview" >&2
     exit 1
 fi
 

package/tests/test_graph_memory.sh

@@ -77,11 +77,70 @@ CREATE TABLE graph_fixture (
 );
 EOF
 
-git -C "$repo" add a.sh b.sh old.sh db/source_column.sql
+cat > "$repo/sqlite_cli_literal.sh" <<'EOF'
+EAGLE_DB_SETUP=".headers off
+.output /dev/null
+PRAGMA busy_timeout=10000;
+.output stdout"
+EOF
+
+{
+    printf '\n'
+    printf '%s\n' 'echo "starts after an intentional blank line"'
+    printf '%s\n' '   '
+} > "$repo/sql_literal_edges.sh"
+
+{
+    printf '%s\n' '   '
+    printf '\t\n'
+} > "$repo/space_only.sh"
+
+: > "$repo/empty.sh"
+
+git -C "$repo" add a.sh b.sh old.sh db/source_column.sql sqlite_cli_literal.sh sql_literal_edges.sh space_only.sh empty.sh
 
 "$EAGLE_BIN" scan --force "$repo" >/dev/null
 "$EAGLE_BIN" index --force "$repo" >/dev/null
 
+dot_command_chunk_count=$(eagle_db "SELECT COUNT(*)
+                                    FROM code_chunks
+                                    WHERE project = 'project'
+                                      AND file_path = 'sqlite_cli_literal.sh'
+                                      AND content LIKE '%.output stdout%';")
+if [ "$dot_command_chunk_count" != "1" ]; then
+    echo "index did not preserve sqlite dot-command-like source lines" >&2
+    exit 1
+fi
+
+leading_blank_hex=$(eagle_db "SELECT hex(substr(content, 1, 1))
+                              FROM code_chunks
+                              WHERE project = 'project'
+                                AND file_path = 'sql_literal_edges.sh'
+                              LIMIT 1;")
+if [ "$leading_blank_hex" != "0A" ]; then
+    echo "index did not preserve leading blank line in SQL literal expression" >&2
+    exit 1
+fi
+
+whitespace_chunk_count=$(eagle_db "SELECT COUNT(*)
+                                   FROM code_chunks
+                                   WHERE project = 'project'
+                                     AND file_path = 'space_only.sh'
+                                     AND length(content) > 0;")
+if [ "$whitespace_chunk_count" != "1" ]; then
+    echo "index did not preserve all-whitespace source chunk" >&2
+    exit 1
+fi
+
+empty_chunk_count=$(eagle_db "SELECT COUNT(*)
+                              FROM code_chunks
+                              WHERE project = 'project'
+                                AND file_path = 'empty.sh';")
+if [ "$empty_chunk_count" != "0" ]; then
+    echo "index should not create chunks for empty files" >&2
+    exit 1
+fi
+
 decl_count=$(eagle_db "SELECT COUNT(*)
                        FROM graph_nodes
                        WHERE project = 'project'

package/tests/test_reliability_guards.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+tmp_dir=$(mktemp -d)
+trap 'rm -rf "$tmp_dir"' EXIT
+
+assert_contains() {
+    local haystack="$1" needle="$2" message="$3"
+    case "$haystack" in
+        *"$needle"*) ;;
+        *)
+            echo "$message" >&2
+            echo "Expected to find: $needle" >&2
+            echo "Actual: $haystack" >&2
+            exit 1
+            ;;
+    esac
+}
+
+# Provider fallback: a failed preferred Codex CLI should fall through to Claude.
+provider_home="$tmp_dir/provider-home"
+fake_bin="$tmp_dir/bin"
+mkdir -p "$provider_home" "$fake_bin"
+cat > "$fake_bin/codex" <<'SH'
+#!/usr/bin/env bash
+exit 42
+SH
+cat > "$fake_bin/claude" <<'SH'
+#!/usr/bin/env bash
+printf 'claude fallback ok\n'
+SH
+chmod +x "$fake_bin/codex" "$fake_bin/claude"
+cat > "$provider_home/config.toml" <<'TOML'
+[provider]
+type = "agent_cli"
+fallback = "auto"
+
+[agent_cli]
+preferred = "codex"
+codex_model = ""
+claude_model = ""
+TOML
+provider_result=$(EAGLE_MEM_DIR="$provider_home" PATH="$fake_bin:$PATH" bash -c "
+    . '$ROOT_DIR/lib/common.sh'
+    . '$ROOT_DIR/lib/provider.sh'
+    eagle_llm_call 'say ok' 'system' 20
+")
+assert_contains "$provider_result" "claude fallback ok" "agent_cli fallback did not use Claude after Codex failed"
+
+# PreToolUse parsing + read scoring: repeated large read after modification should emit scored context.
+hook_home="$tmp_dir/hook-home"
+repo="$tmp_dir/repo"
+mkdir -p "$hook_home/mod-tracker" "$repo"
+touch "$hook_home/memory.db"
+large_file="$repo/large.txt"
+dd if=/dev/zero bs=1024 count=600 2>/dev/null | tr '\0' 'x' > "$large_file"
+session_id="session_reliability_123"
+printf '%s\n' "$large_file" > "$hook_home/mod-tracker/$session_id"
+read_input=$(jq -nc --arg fp "$large_file" --arg sid "$session_id" --arg cwd "$repo" \
+    '{tool_name:"Read",session_id:$sid,cwd:$cwd,tool_input:{file_path:$fp}}')
+EAGLE_MEM_DIR="$hook_home" EAGLE_MEM_PROJECT="project-read" bash "$ROOT_DIR/hooks/pre-tool-use.sh" <<< "$read_input" >/dev/null
+EAGLE_MEM_DIR="$hook_home" EAGLE_MEM_PROJECT="project-read" bash "$ROOT_DIR/hooks/pre-tool-use.sh" <<< "$read_input" >/dev/null
+read_output=$(EAGLE_MEM_DIR="$hook_home" EAGLE_MEM_PROJECT="project-read" bash "$ROOT_DIR/hooks/pre-tool-use.sh" <<< "$read_input")
+assert_contains "$read_output" "Eagle Mem read score" "Read guard did not emit scored duplicate-read context"
+grep -q 'mod_file}.lock' "$ROOT_DIR/hooks/post-tool-use.sh" || {
+    echo "post-tool-use modification tracker should use a lock directory" >&2
+    exit 1
+}
+
+# Auto-scan state race: failed background scan must clear the freshness marker.
+state_home="$tmp_dir/state-home"
+auto_scripts="$tmp_dir/auto-scripts"
+auto_repo="$tmp_dir/auto-repo"
+mkdir -p "$state_home" "$auto_scripts" "$auto_repo"
+cat > "$auto_scripts/scan.sh" <<'SH'
+#!/usr/bin/env bash
+exit 9
+SH
+cat > "$auto_scripts/index.sh" <<'SH'
+#!/usr/bin/env bash
+exit 0
+SH
+EAGLE_MEM_DIR="$state_home" EAGLE_MEM_LOG="$state_home/eagle-mem.log" bash -c "
+    . '$ROOT_DIR/lib/common.sh'
+    . '$ROOT_DIR/lib/hooks-sessionstart.sh'
+    eagle_get_overview() { return 0; }
+    eagle_db() { printf '0\n'; }
+    eagle_sessionstart_auto_provision 'project-auto-fail' '$auto_repo' '$auto_scripts'
+    scan_state=\$(_eagle_state_file scan 'project-auto-fail')
+    for _i in 1 2 3 4 5 6 7 8 9 10; do
+        grep -q 'auto-scan failed' '$state_home/eagle-mem.log' 2>/dev/null && break
+        sleep 0.2
+    done
+    [ ! -f \"\$scan_state\" ]
+"
+
+# Command-scoped logs: scan should create an inspectable run log and logs list should show it.
+log_home="$tmp_dir/log-home"
+log_repo="$tmp_dir/log-repo"
+mkdir -p "$log_home" "$log_repo"
+printf '# demo\n' > "$log_repo/README.md"
+EAGLE_MEM_DIR="$log_home" bash "$ROOT_DIR/scripts/scan.sh" "$log_repo" >/dev/null
+log_list=$(EAGLE_MEM_DIR="$log_home" bash "$ROOT_DIR/bin/eagle-mem" logs list)
+assert_contains "$log_list" "command=scan" "logs list did not show the scan command run"
+
+echo "reliability guard regressions passed"