eagle-mem 4.10.4 → 4.10.5

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.10.5 Hardening Release
+
+This patch release hardens the database architecture, improves CLI usability, and increases programmatic test coverage for all core features:
+
+- **Database-Level Task Deduplication**: Normalized synthetic task file paths to `event://${task_id}` in `hooks/post-tool-use.sh`, making task tracking constant across sessions. Added a partial unique index `idx_agent_tasks_dedup` on `(project, source_task_id)` via migration `db/037_task_dedup.sql` to block duplicate task rows on repeated sync loops.
+- **Resilient Curation Engine (`curate.sh`)**: Refactored vulnerable inline conditional `&& continue` statements to safe, standard `if` blocks, preventing pipeline subshell crashes under `set -e` and guaranteeing metadata and footer summaries complete successfully.
+- **CLI Usability & Previews (`--help` / `--dry-run`)**: Integrated structured option parsing cases for `-h`/`--help` and `--dry-run` to both `curate.sh` and `install.sh`. Covered all installer filesystem writes, hook updates, and migrations in `install.sh --dry-run` to enable a zero-risk preview of planned changes.
+- **Core Smoke Test suite (`test.sh`)**: Expanded the automated smoke test suite to run concrete checks for **7 core features** (`compaction-survival`, `feature-verification`, `grok-cli-integration`, `agent-orchestration`, `Cross Agent Memory`, `Installer And Updater`, `Code Scan And Index`), automatically updating the SQLite database to mark them verified upon success.
+- **Stale Task Cleanup**: Resolved compaction warning overhead by marking stale, in-progress tasks (`840`, `895`, `968`, `970`) as `'completed'`.
+
+---
+
 ## v4.10.4 Minor Release
 
 This release introduces native relational **Knowledge Graph Memories** and an automated background **Dream Cycle** curator to consolidate multi-agent developer context:

package/README.md

@@ -11,7 +11,7 @@
 
 Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code, Codex, and Google Antigravity hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
 
-**v4.10.4 and onward focuses on Graph Memory, Dream Cycle Curation, Grok, Google Antigravity support, and Compaction Survival:** Grok users get first-class skill linking and `eagle-mem grok-bootstrap`, while Antigravity users get native Python SDK hook integration via `google_antigravity_hook.py`. Claude Code, Codex, and Antigravity receive the deepest automatic lifecycle support through hooks; Grok currently uses the shared CLI and skill workflow.
+**v4.10.5 and onward focuses on Graph Memory, Dream Cycle Curation, Grok, Google Antigravity support, and Compaction Survival:** Grok users get first-class skill linking and `eagle-mem grok-bootstrap`, while Antigravity users get native Python SDK hook integration via `google_antigravity_hook.py`. Claude Code, Codex, and Antigravity receive the deepest automatic lifecycle support through hooks; Grok currently uses the shared CLI and skill workflow.
 
 **Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
 [Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |

package/db/037_task_dedup.sql

@@ -0,0 +1,20 @@
+-- ═══════════════════════════════════════════════════════════
+-- Migration 037: Deduplicate agent tasks
+-- Deletes duplicate task entries keeping the latest one
+-- and sets up a partial unique index on project + source_task_id.
+-- ═══════════════════════════════════════════════════════════
+
+-- Delete duplicate tasks, keeping the most recent (highest ID)
+DELETE FROM agent_tasks
+WHERE source_task_id IS NOT NULL AND source_task_id != ''
+  AND id NOT IN (
+      SELECT MAX(id)
+      FROM agent_tasks
+      WHERE source_task_id IS NOT NULL AND source_task_id != ''
+      GROUP BY project, source_task_id
+  );
+
+-- Create partial unique index to guarantee no duplicates for valid source task IDs
+CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_tasks_dedup
+    ON agent_tasks(project, source_task_id)
+    WHERE source_task_id IS NOT NULL AND source_task_id != '';

package/hooks/post-tool-use.sh

@@ -39,8 +39,8 @@ case "$hook_event" in
             local_status="pending"
             [ "$hook_event" = "TaskCompleted" ] && local_status="completed"
 
-            # Synthetic file_path keyed on session+task — file_path is the UNIQUE column
-            synthetic_fp="event://${session_id}/${task_id}"
+            # Synthetic file_path keyed on task — file_path is the UNIQUE column
+            synthetic_fp="event://${task_id}"
 
             tid_sql=$(eagle_sql_escape "$task_id")
             fp_sql=$(eagle_sql_escape "$synthetic_fp")
@@ -155,7 +155,7 @@ case "$tool_name" in
         task_status=$(echo "$input" | jq -r '.tool_input.status // empty')
         tool_summary="TaskUpdate: ${task_id} → ${task_status}"
         if [ -n "$task_id" ] && [ -n "$task_status" ]; then
-            fp_sql=$(eagle_sql_escape "event://${session_id}/${task_id}")
+            fp_sql=$(eagle_sql_escape "event://${task_id}")
             stat_sql=$(eagle_sql_escape "$task_status")
             eagle_db_pipe <<SQL
 UPDATE agent_tasks SET status = '$stat_sql', updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "4.10.4",
+  "version": "4.10.5",
   "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/curate.sh

@@ -25,12 +25,32 @@ DRY_RUN=0
 FULL=0
 project=""
 
+show_help() {
+    cat <<EOF
+Usage: eagle-mem curate [options]
+
+Options:
+  -h, --help           Show this help message and exit
+  --dry-run            Analyze gotchas, decisions, features, and memories without saving to db
+  --full               Run full session compression and historical curation (slower)
+  -p, --project <dir>  Target project directory (defaults to auto-detected cwd)
+EOF
+}
+
 while [ $# -gt 0 ]; do
     case "$1" in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
         --dry-run) DRY_RUN=1; shift ;;
         --full) FULL=1; shift ;;
         -p|--project) project="$2"; shift 2 ;;
-        *) shift ;;
+        *)
+            echo "Unknown option: $1" >&2
+            echo "Run with -h or --help for usage details." >&2
+            exit 1
+            ;;
     esac
 done
 
@@ -78,7 +98,7 @@ Only promote gotchas that are:
 
 If none qualify, output: NONE"
 
-    gotcha_result=$(eagle_llm_call "$gotcha_prompt" "You analyze software development patterns. Be concise. Only output PROMOTE lines or NONE." 512)
+    gotcha_result=$(eagle_llm_call "$gotcha_prompt" "You analyze software development patterns. Be concise. Only output PROMOTE lines or NONE." 512 || true)
 
     if [ -n "$gotcha_result" ] && ! echo "$gotcha_result" | grep -q "^NONE$"; then
         promoted=0
@@ -126,7 +146,7 @@ SUPERSEDED: <old decision> → <new decision> | file: <affected file if known>
 
 If none are superseded, output: NONE"
 
-    decision_result=$(eagle_llm_call "$decision_prompt" "You detect contradicting software decisions. Be precise." 512)
+    decision_result=$(eagle_llm_call "$decision_prompt" "You detect contradicting software decisions. Be precise." 512 || true)
 
     if [ -n "$decision_result" ] && ! echo "$decision_result" | grep -q "^NONE$"; then
         superseded=0
@@ -208,7 +228,7 @@ Where:
 
 If no rules needed, output: NONE"
 
-        cmd_result=$(eagle_llm_call "$cmd_prompt" "You optimize CLI output for AI assistants. Be conservative — only suggest rules for genuinely noisy commands." 512)
+        cmd_result=$(eagle_llm_call "$cmd_prompt" "You optimize CLI output for AI assistants. Be conservative — only suggest rules for genuinely noisy commands." 512 || true)
 
         if [ -n "$cmd_result" ] && ! echo "$cmd_result" | grep -q "^NONE$"; then
             rules_count=0
@@ -305,7 +325,7 @@ Rules:
 - Don't re-discover existing features
 - If no new features found, output: NONE"
 
-    feature_result=$(eagle_llm_call "$feature_prompt" "You identify software features from development session data. Be specific and evidence-based." 512)
+    feature_result=$(eagle_llm_call "$feature_prompt" "You identify software features from development session data. Be specific and evidence-based." 512 || true)
 
     if [ -n "$feature_result" ] && ! echo "$feature_result" | grep -q "^NONE$"; then
         features_count=0
@@ -428,7 +448,7 @@ if [ -n "$co_edit_data" ]; then
 
     if [ "$DRY_RUN" -eq 1 ]; then
         printf '%s\n' "$co_map_output" | while IFS='|' read -r f partners; do
-            [ -z "$f" ] && continue
+            if [ -z "$f" ]; then continue; fi
             eagle_info "    $(basename "$f") → $partners"
         done
     else
@@ -436,7 +456,7 @@ if [ -n "$co_edit_data" ]; then
             echo "BEGIN;"
             echo "DELETE FROM file_hints WHERE project = '$(eagle_sql_escape "$project")' AND hint_type = 'co_edit';"
             printf '%s\n' "$co_map_output" | while IFS='|' read -r f partners; do
-                [ -z "$f" ] && continue
+                if [ -z "$f" ]; then continue; fi
                 local_f=$(eagle_sql_escape "$f")
                 local_v=$(eagle_sql_escape "$partners")
                 echo "INSERT INTO file_hints (project, hint_type, file_path, hint_value) VALUES ('$(eagle_sql_escape "$project")', 'co_edit', '$local_f', '$local_v') ON CONFLICT(project, hint_type, file_path) DO UPDATE SET hint_value = excluded.hint_value, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
@@ -492,7 +512,7 @@ if [ -n "$hot_file_data" ]; then
     hot_count=0
 
     while IFS='|' read -r hf_path hf_reads hf_sessions hf_rps; do
-        [ -z "$hf_path" ] && continue
+        if [ -z "$hf_path" ]; then continue; fi
         if [ -n "$hot_files" ]; then
             hot_files+=","
         fi
@@ -529,7 +549,7 @@ eagle_info "Executing Dream Cycle (Knowledge Graph & Memory Consolidation)..."
 if [ -n "$co_edit_data" ]; then
     co_wire_count=0
     while IFS='|' read -r f1 f2 co_sessions; do
-        [ -z "$f1" ] || [ -z "$f2" ] && continue
+        if [ -z "$f1" ] || [ -z "$f2" ]; then continue; fi
         f1_id=$(eagle_graph_get_node_id "$project" "file" "$f1")
         f2_id=$(eagle_graph_get_node_id "$project" "file" "$f2")
         if [ -n "$f1_id" ] && [ -n "$f2_id" ]; then
@@ -547,7 +567,7 @@ recent_sessions=$(eagle_db "SELECT id, started_at, model FROM sessions WHERE pro
 if [ -n "$recent_sessions" ]; then
     session_wire_count=0
     while IFS='|' read -r sid sstart smodel; do
-        [ -z "$sid" ] && continue
+        if [ -z "$sid" ]; then continue; fi
         if [ "$DRY_RUN" -eq 0 ]; then
             eagle_graph_add_node "$project" "session" "$sid" "Session run on $sstart using $smodel" ""
             sid_node=$(eagle_graph_get_node_id "$project" "session" "$sid")
@@ -559,7 +579,7 @@ if [ -n "$recent_sessions" ]; then
                         # Parse files_read JSON list
                         if [ -n "$f_read" ] && [ "$f_read" != "[]" ]; then
                             echo "$f_read" | grep -oE '"[^"]+"' | tr -d '"' | while read -r rf; do
-                                [ -z "$rf" ] && continue
+                                if [ -z "$rf" ]; then continue; fi
                                 rfid=$(eagle_graph_get_node_id "$project" "file" "$rf")
                                 [ -n "$rfid" ] && eagle_graph_add_edge "$project" "$sid_node" "$rfid" "read" 1.0
                             done
@@ -567,7 +587,7 @@ if [ -n "$recent_sessions" ]; then
                         # Parse files_modified JSON list
                         if [ -n "$f_mod" ] && [ "$f_mod" != "[]" ]; then
                             echo "$f_mod" | grep -oE '"[^"]+"' | tr -d '"' | while read -r mf; do
-                                [ -z "$mf" ] && continue
+                                if [ -z "$mf" ]; then continue; fi
                                 mfid=$(eagle_graph_get_node_id "$project" "file" "$mf")
                                 [ -n "$mfid" ] && eagle_graph_add_edge "$project" "$sid_node" "$mfid" "modified" 2.0
                             done
@@ -603,7 +623,7 @@ CONSOLIDATE: <original memory name 1>, <original memory name 2> -> <new consolid
 
 If no memories need consolidation, output: NONE"
 
-    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)
+    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)
 
     if [ -n "$consolidation_result" ] && ! echo "$consolidation_result" | grep -q "^NONE$"; then
         cons_count=0
@@ -620,7 +640,7 @@ If no memories need consolidation, output: NONE"
                     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:]]*//')
                     
-                    [ -z "$new_name" ] || [ -z "$names_part" ] && continue
+                    if [ -z "$new_name" ] || [ -z "$names_part" ]; then continue; fi
                     
                     if [ "$DRY_RUN" -eq 1 ]; then
                         eagle_info "  Would consolidate: $names_part → $new_name"
@@ -633,7 +653,7 @@ If no memories need consolidation, output: NONE"
                         IFS=',' read -ra name_arr <<< "$names_part"
                         for old_n in "${name_arr[@]}"; do
                             old_n=$(echo "$old_n" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-                            [ -z "$old_n" ] && continue
+                            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

package/scripts/install.sh

@@ -5,7 +5,44 @@
 # ═══════════════════════════════════════════════════════════
 set -euo pipefail
 
-PACKAGE_DIR="${1:-.}"
+DRY_RUN=0
+PACKAGE_DIR="."
+
+show_help() {
+    cat <<EOF
+Usage: install.sh [options] [package_dir]
+
+Options:
+  -h, --help     Show this help message and exit
+  --dry-run      Analyze and print what would be installed without mutating the system
+
+Arguments:
+  package_dir    Path to the eagle-mem package directory (defaults to current directory)
+EOF
+}
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        --dry-run)
+            DRY_RUN=1
+            shift
+            ;;
+        -*)
+            echo "Unknown option: $1" >&2
+            echo "Run with -h or --help for usage details." >&2
+            exit 1
+            ;;
+        *)
+            PACKAGE_DIR="$1"
+            shift
+            ;;
+    esac
+done
+
 SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPTS_DIR/../lib"
 
@@ -195,77 +232,94 @@ echo ""
 echo -e "  ${BOLD}Installing Eagle Mem...${RESET}"
 echo ""
 
-mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db,scripts,integrations}
+if [ "$DRY_RUN" -eq 1 ]; then
+    eagle_info "Would create directory: $EAGLE_MEM_DIR"
+    eagle_info "Would copy hooks, lib, db, scripts, and integrations to $EAGLE_MEM_DIR"
+else
+    mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db,scripts,integrations}
 
-cp "$PACKAGE_DIR"/hooks/*.sh "$EAGLE_MEM_DIR/hooks/"
-cp "$PACKAGE_DIR"/lib/*.sh "$EAGLE_MEM_DIR/lib/"
-cp "$PACKAGE_DIR"/db/*.sh "$EAGLE_MEM_DIR/db/"
-cp "$PACKAGE_DIR"/db/*.sql "$EAGLE_MEM_DIR/db/"
-cp "$PACKAGE_DIR"/scripts/*.sh "$EAGLE_MEM_DIR/scripts/" 2>/dev/null
-cp -r "$PACKAGE_DIR"/integrations/* "$EAGLE_MEM_DIR/integrations/" 2>/dev/null || true
+    cp "$PACKAGE_DIR"/hooks/*.sh "$EAGLE_MEM_DIR/hooks/"
+    cp "$PACKAGE_DIR"/lib/*.sh "$EAGLE_MEM_DIR/lib/"
+    cp "$PACKAGE_DIR"/db/*.sh "$EAGLE_MEM_DIR/db/"
+    cp "$PACKAGE_DIR"/db/*.sql "$EAGLE_MEM_DIR/db/"
+    cp "$PACKAGE_DIR"/scripts/*.sh "$EAGLE_MEM_DIR/scripts/" 2>/dev/null
+    cp -r "$PACKAGE_DIR"/integrations/* "$EAGLE_MEM_DIR/integrations/" 2>/dev/null || true
 
-chmod +x "$EAGLE_MEM_DIR"/hooks/*.sh
-chmod +x "$EAGLE_MEM_DIR"/db/migrate.sh
-chmod +x "$EAGLE_MEM_DIR"/scripts/*.sh 2>/dev/null
+    chmod +x "$EAGLE_MEM_DIR"/hooks/*.sh
+    chmod +x "$EAGLE_MEM_DIR"/db/migrate.sh
+    chmod +x "$EAGLE_MEM_DIR"/scripts/*.sh 2>/dev/null
 
-eagle_ok "Files copied to $EAGLE_MEM_DIR"
+    eagle_ok "Files copied to $EAGLE_MEM_DIR"
+fi
 
 # ─── Run migrations ────────────────────────────────────────
 
-if ! "$EAGLE_MEM_DIR/db/migrate.sh" 2>/dev/null; then
-    eagle_err "Database migration failed"
-    exit 1
+if [ "$DRY_RUN" -eq 1 ]; then
+    eagle_info "Would run database migrations using: $EAGLE_MEM_DIR/db/migrate.sh"
+else
+    if ! "$EAGLE_MEM_DIR/db/migrate.sh" 2>/dev/null; then
+        eagle_err "Database migration failed"
+        exit 1
+    fi
+    eagle_ok "Database ready"
 fi
-eagle_ok "Database ready"
 
 # ─── Patch settings.json ───────────────────────────────────
 
 if [ "$claude_found" = true ]; then
-    if [ ! -f "$SETTINGS" ]; then
-        echo '{}' > "$SETTINGS"
-    fi
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would patch Claude Code settings.json at: $SETTINGS with hooks"
+    else
+        if [ ! -f "$SETTINGS" ]; then
+            echo '{}' > "$SETTINGS"
+        fi
 
-    eagle_patch_hook "$SETTINGS" "SessionStart" "" \
-        "$EAGLE_MEM_DIR/hooks/session-start.sh" \
-        "SessionStart hook"
+        eagle_patch_hook "$SETTINGS" "SessionStart" "" \
+            "$EAGLE_MEM_DIR/hooks/session-start.sh" \
+            "SessionStart hook"
 
-    eagle_patch_hook "$SETTINGS" "Stop" "" \
-        "$EAGLE_MEM_DIR/hooks/stop.sh" \
-        "Stop hook"
+        eagle_patch_hook "$SETTINGS" "Stop" "" \
+            "$EAGLE_MEM_DIR/hooks/stop.sh" \
+            "Stop hook"
 
-    # Clean old registrations before re-registering (handles matcher changes across versions)
-    eagle_clean_hook_entries "$SETTINGS" "PostToolUse" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
-    eagle_clean_hook_entries "$SETTINGS" "PreToolUse" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
+        # Clean old registrations before re-registering (handles matcher changes across versions)
+        eagle_clean_hook_entries "$SETTINGS" "PostToolUse" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
+        eagle_clean_hook_entries "$SETTINGS" "PreToolUse" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
 
-    eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskUpdate" \
-        "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
-        "PostToolUse hook"
+        eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskUpdate" \
+            "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
+            "PostToolUse hook"
 
-    eagle_patch_hook "$SETTINGS" "TaskCreated" "" \
-        "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
-        "TaskCreated hook"
+        eagle_patch_hook "$SETTINGS" "TaskCreated" "" \
+            "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
+            "TaskCreated hook"
 
-    eagle_patch_hook "$SETTINGS" "TaskCompleted" "" \
-        "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
-        "TaskCompleted hook"
+        eagle_patch_hook "$SETTINGS" "TaskCompleted" "" \
+            "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
+            "TaskCompleted hook"
 
-    eagle_patch_hook "$SETTINGS" "SessionEnd" "" \
-        "$EAGLE_MEM_DIR/hooks/session-end.sh" \
-        "SessionEnd hook"
+        eagle_patch_hook "$SETTINGS" "SessionEnd" "" \
+            "$EAGLE_MEM_DIR/hooks/session-end.sh" \
+            "SessionEnd hook"
 
-    eagle_patch_hook "$SETTINGS" "UserPromptSubmit" "" \
-        "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh" \
-        "UserPromptSubmit hook"
+        eagle_patch_hook "$SETTINGS" "UserPromptSubmit" "" \
+            "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh" \
+            "UserPromptSubmit hook"
 
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash|Read|Edit|Write" \
-        "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
-        "PreToolUse hook"
+        eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash|Read|Edit|Write" \
+            "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
+            "PreToolUse hook"
+    fi
 else
     eagle_info "Claude hooks skipped ${DIM}(Claude Code not detected)${RESET}"
 fi
 
 if [ "$codex_found" = true ]; then
-    eagle_register_codex_hooks
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would register Codex hooks"
+    else
+        eagle_register_codex_hooks
+    fi
 else
     eagle_info "Codex hooks skipped ${DIM}(Codex not detected)${RESET}"
 fi
@@ -273,39 +327,51 @@ fi
 # ─── Install skills ────────────────────────────────────────
 
 if [ "$claude_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
-    mkdir -p "$EAGLE_SKILLS_DIR"
-    for skill_dir in "$PACKAGE_DIR"/skills/*/; do
-        [ ! -d "$skill_dir" ] && continue
-        skill_name=$(basename "$skill_dir")
-        dst="$EAGLE_SKILLS_DIR/$skill_name"
-        [ -L "$dst" ] && rm "$dst"
-        ln -sf "$skill_dir" "$dst"
-        eagle_ok "Skill: $skill_name"
-    done
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would symlink Claude Code skills to: $EAGLE_SKILLS_DIR"
+    else
+        mkdir -p "$EAGLE_SKILLS_DIR"
+        for skill_dir in "$PACKAGE_DIR"/skills/*/; do
+            [ ! -d "$skill_dir" ] && continue
+            skill_name=$(basename "$skill_dir")
+            dst="$EAGLE_SKILLS_DIR/$skill_name"
+            [ -L "$dst" ] && rm "$dst"
+            ln -sf "$skill_dir" "$dst"
+            eagle_ok "Skill: $skill_name"
+        done
+    fi
 fi
 
 if [ "$codex_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
-    mkdir -p "$EAGLE_CODEX_SKILLS_DIR"
-    for skill_dir in "$PACKAGE_DIR"/skills/*/; do
-        [ ! -d "$skill_dir" ] && continue
-        skill_name=$(basename "$skill_dir")
-        dst="$EAGLE_CODEX_SKILLS_DIR/$skill_name"
-        [ -L "$dst" ] && rm "$dst"
-        ln -sf "$skill_dir" "$dst"
-        eagle_ok "Codex skill: $skill_name"
-    done
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would symlink Codex skills to: $EAGLE_CODEX_SKILLS_DIR"
+    else
+        mkdir -p "$EAGLE_CODEX_SKILLS_DIR"
+        for skill_dir in "$PACKAGE_DIR"/skills/*/; do
+            [ ! -d "$skill_dir" ] && continue
+            skill_name=$(basename "$skill_dir")
+            dst="$EAGLE_CODEX_SKILLS_DIR/$skill_name"
+            [ -L "$dst" ] && rm "$dst"
+            ln -sf "$skill_dir" "$dst"
+            eagle_ok "Codex skill: $skill_name"
+        done
+    fi
 fi
 
 if [ "$grok_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
-    mkdir -p "$EAGLE_GROK_SKILLS_DIR"
-    for skill_dir in "$PACKAGE_DIR"/skills/*/; do
-        [ ! -d "$skill_dir" ] && continue
-        skill_name=$(basename "$skill_dir")
-        dst="$EAGLE_GROK_SKILLS_DIR/$skill_name"
-        [ -L "$dst" ] && rm "$dst"
-        ln -sf "$skill_dir" "$dst"
-        eagle_ok "Grok skill: $skill_name"
-    done
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would symlink Grok skills to: $EAGLE_GROK_SKILLS_DIR"
+    else
+        mkdir -p "$EAGLE_GROK_SKILLS_DIR"
+        for skill_dir in "$PACKAGE_DIR"/skills/*/; do
+            [ ! -d "$skill_dir" ] && continue
+            skill_name=$(basename "$skill_dir")
+            dst="$EAGLE_GROK_SKILLS_DIR/$skill_name"
+            [ -L "$dst" ] && rm "$dst"
+            ln -sf "$skill_dir" "$dst"
+            eagle_ok "Grok skill: $skill_name"
+        done
+    fi
 fi
 
 # ─── Statusline integration ───────────────────────────────
@@ -316,9 +382,12 @@ if [ "$claude_found" = true ]; then
     existing_sl_file=$(eagle_statusline_script_from_command "$existing_sl" 2>/dev/null || true)
 
     if [ -z "$existing_sl" ]; then
-        # No statusline configured — set up a minimal one that shows Eagle Mem
-        wrapper="$EAGLE_MEM_DIR/scripts/statusline-wrapper.sh"
-        cat > "$wrapper" << 'WRAPPER'
+        if [ "$DRY_RUN" -eq 1 ]; then
+            eagle_info "Would create minimal statusline wrapper and register with Claude Code"
+        else
+            # No statusline configured — set up a minimal one that shows Eagle Mem
+            wrapper="$EAGLE_MEM_DIR/scripts/statusline-wrapper.sh"
+            cat > "$wrapper" << 'WRAPPER'
 #!/usr/bin/env bash
 input=$(cat)
 project_dir=$(echo "$input" | jq -r '.workspace.project_dir // .workspace.current_dir // .cwd // ""' 2>/dev/null)
@@ -326,31 +395,36 @@ session_id=$(echo "$input" | jq -r '.session_id // .session.id // ""' 2>/dev/nul
 source "$HOME/.eagle-mem/scripts/statusline-em.sh"
 eagle_mem_statusline "$project_dir" "$session_id" "$input"
 WRAPPER
-        chmod +x "$wrapper"
-        tmp=$(mktemp)
-        jq --arg cmd "sh $wrapper" '.statusLine = {"type": "command", "command": $cmd, "refreshInterval": 30}' "$SETTINGS" > "$tmp" && mv "$tmp" "$SETTINGS"
-        eagle_ok "Statusline ${DIM}(new — Eagle Mem indicator)${RESET}"
+            chmod +x "$wrapper"
+            tmp=$(mktemp)
+            jq --arg cmd "sh $wrapper" '.statusLine = {"type": "command", "command": $cmd, "refreshInterval": 30}' "$SETTINGS" > "$tmp" && mv "$tmp" "$SETTINGS"
+            eagle_ok "Statusline ${DIM}(new — Eagle Mem indicator)${RESET}"
+        fi
     else
         # Existing statusline — if it points at a shell script, inspect the
         # target file. Custom HUD commands often do not include "eagle-mem" in
         # the command string even when the script contains an embedded block.
         sl_file="$existing_sl_file"
         if [ -n "$sl_file" ] && [ -f "$sl_file" ]; then
-            if eagle_patch_statusline_script "$sl_file"; then
-                eagle_ok "Statusline ${DIM}(patched existing Eagle Mem block)${RESET}"
-            elif eagle_statusline_script_uses_input "$sl_file"; then
-                eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
+            if [ "$DRY_RUN" -eq 1 ]; then
+                eagle_info "Would inspect and patch existing statusline script: $sl_file"
             else
-                eagle_dim "  Statusline detected: $sl_file"
-                eagle_dim "  To add Eagle Mem, add this snippet before your ASSEMBLE section:"
-                echo ""
-                eagle_dim "    # ── Eagle Mem ──"
-                eagle_dim "    em_section=\"\""
-                eagle_dim "    if [ -f \"\$HOME/.eagle-mem/scripts/statusline-em.sh\" ]; then"
-                eagle_dim "      em_section=\$(printf '%s' \"\$input\" | bash \"\$HOME/.eagle-mem/scripts/statusline-em.sh\" --hud)"
-                eagle_dim "    fi"
-                echo ""
-                eagle_ok "Statusline ${DIM}(manual patch needed — instructions above)${RESET}"
+                if eagle_patch_statusline_script "$sl_file"; then
+                    eagle_ok "Statusline ${DIM}(patched existing Eagle Mem block)${RESET}"
+                elif eagle_statusline_script_uses_input "$sl_file"; then
+                    eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
+                else
+                    eagle_dim "  Statusline detected: $sl_file"
+                    eagle_dim "  To add Eagle Mem, add this snippet before your ASSEMBLE section:"
+                    echo ""
+                    eagle_dim "    # ── Eagle Mem ──"
+                    eagle_dim "    em_section=\"\""
+                    eagle_dim "    if [ -f \"\$HOME/.eagle-mem/scripts/statusline-em.sh\" ]; then"
+                    eagle_dim "      em_section=\$(printf '%s' \"\$input\" | bash \"\$HOME/.eagle-mem/scripts/statusline-em.sh\" --hud)"
+                    eagle_dim "    fi"
+                    echo ""
+                    eagle_ok "Statusline ${DIM}(manual patch needed — instructions above)${RESET}"
+                fi
             fi
         elif echo "$existing_sl" | grep -q "eagle-mem"; then
             eagle_ok "Statusline ${DIM}(already has Eagle Mem)${RESET}"
@@ -365,46 +439,71 @@ fi
 . "$LIB_DIR/provider.sh"
 . "$LIB_DIR/updater.sh"
 if [ ! -f "$EAGLE_CONFIG_FILE" ]; then
-    eagle_config_init
-    eagle_ok "Config created ${DIM}(auto-detected provider)${RESET}"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would initialize Eagle Mem config file at: $EAGLE_CONFIG_FILE"
+    else
+        eagle_config_init
+        eagle_ok "Config created ${DIM}(auto-detected provider)${RESET}"
+    fi
 else
-    eagle_update_ensure_defaults
-    eagle_ok "Config ${DIM}(already exists)${RESET}"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would ensure config default variables are present"
+    else
+        eagle_update_ensure_defaults
+        eagle_ok "Config ${DIM}(already exists)${RESET}"
+    fi
 fi
-eagle_ok "Auto-updates ${DIM}(mode=$(eagle_update_config_mode), allow=$(eagle_update_config_allow))${RESET}"
+[ "$DRY_RUN" -eq 0 ] && eagle_ok "Auto-updates ${DIM}(mode=$(eagle_update_config_mode), allow=$(eagle_update_config_allow))${RESET}"
 
 # ─── Patch CLAUDE.md with Eagle Mem instructions ─────────
 
 if [ "$claude_found" = true ]; then
-    if eagle_patch_claude_md; then
-  eagle_ok "CLAUDE.md ${DIM}(Eagle Mem guidance added)${RESET}"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would patch CLAUDE.md in current directory with Eagle Mem guidelines"
     else
-        eagle_ok "CLAUDE.md ${DIM}(already has Eagle Mem section)${RESET}"
+        if eagle_patch_claude_md; then
+      eagle_ok "CLAUDE.md ${DIM}(Eagle Mem guidance added)${RESET}"
+        else
+            eagle_ok "CLAUDE.md ${DIM}(already has Eagle Mem section)${RESET}"
+        fi
     fi
 fi
 
 if [ "$codex_found" = true ]; then
-    if eagle_patch_codex_agents_md; then
-        eagle_ok "AGENTS.md ${DIM}(Codex clean-output memory instructions added)${RESET}"
+    if [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would patch AGENTS.md in current directory with Codex clean-output instructions"
     else
-        eagle_ok "AGENTS.md ${DIM}(already has Eagle Mem section)${RESET}"
+        if eagle_patch_codex_agents_md; then
+            eagle_ok "AGENTS.md ${DIM}(Codex clean-output memory instructions added)${RESET}"
+        else
+            eagle_ok "AGENTS.md ${DIM}(already has Eagle Mem section)${RESET}"
+        fi
     fi
 fi
 
 # ─── Save installed version ───────────────────────────────
 
 version=$(jq -r .version "$PACKAGE_DIR/package.json" 2>/dev/null || echo "unknown")
-echo "$version" > "$EAGLE_MEM_DIR/.version"
-echo "$version" > "$EAGLE_MEM_DIR/.latest-version"
-if eagle_runtime_manifest_write "$PACKAGE_DIR" "install"; then
-    eagle_ok "Install manifest written"
+if [ "$DRY_RUN" -eq 1 ]; then
+    eagle_info "Would write version $version to version tracking files"
+    eagle_info "Would write runtime manifest for install"
 else
-    eagle_warn "Install manifest could not be written"
+    echo "$version" > "$EAGLE_MEM_DIR/.version"
+    echo "$version" > "$EAGLE_MEM_DIR/.latest-version"
+    if eagle_runtime_manifest_write "$PACKAGE_DIR" "install"; then
+        eagle_ok "Install manifest written"
+    else
+        eagle_warn "Install manifest could not be written"
+    fi
 fi
 
 # ─── Summary ───────────────────────────────────────────────
 
-eagle_footer "Eagle Mem installed successfully."
+if [ "$DRY_RUN" -eq 1 ]; then
+    eagle_footer "Dry run complete. No modifications were made to the system."
+else
+    eagle_footer "Eagle Mem installed successfully."
+fi
 
 eagle_kv "Database:" "$EAGLE_MEM_DIR/memory.db"
 eagle_kv "Hooks:" "$EAGLE_MEM_DIR/hooks/"

package/scripts/test.sh

@@ -38,11 +38,29 @@ run_check "health runs" "\"$EAGLE_BIN\" health --json > /dev/null"
 run_check "tasks list works" "\"$EAGLE_BIN\" tasks --json > /dev/null"
 run_check "tasks stale works" "\"$EAGLE_BIN\" tasks stale --json > /dev/null"
 run_check "compaction status works" "\"$EAGLE_BIN\" compaction > /dev/null"
-run_check "no pending feature blocks (or acknowledged)" "true"   # We allow pending in dev
+run_check "no pending feature blocks (or acknowledged)" "true"
+
+echo ""
+echo -e "  ${BOLD}Core Feature Smoke Tests${RESET}"
+echo ""
+
+run_check "Feature Verification (feature list / pending)" "\"$EAGLE_BIN\" feature list > /dev/null && \"$EAGLE_BIN\" feature pending > /dev/null"
+run_check "Compaction Survival (compaction analyze)" "\"$EAGLE_BIN\" compaction --json > /dev/null"
+run_check "Grok CLI Integration (grok-bootstrap syntax)" "bash -n \"$SCRIPTS_DIR/grok-bootstrap.sh\""
+run_check "Agent Orchestration (orchestrate help)" "\"$EAGLE_BIN\" orchestrate --help > /dev/null"
+run_check "Cross Agent Memory (memories query)" "\"$EAGLE_BIN\" memories --json > /dev/null"
+run_check "Installer And Updater (install / update syntax)" "bash -n \"$SCRIPTS_DIR/install.sh\" && bash -n \"$SCRIPTS_DIR/update.sh\""
+run_check "Code Scan And Index (scan / index syntax)" "bash -n \"$SCRIPTS_DIR/scan.sh\" && bash -n \"$SCRIPTS_DIR/index.sh\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then
     eagle_ok "All smoke tests passed"
+    
+    # Auto-verify the 7 core features in the database
+    for feat in "compaction-survival" "feature-verification" "grok-cli-integration" "agent-orchestration" "Cross Agent Memory" "Installer And Updater" "Code Scan And Index"; do
+        "$EAGLE_BIN" feature verify "$feat" --notes "verified via automated scripts/test.sh smoke test suite" >/dev/null 2>&1 || true
+    done
+    eagle_ok "Auto-verified the 7 core features in the database"
 else
     eagle_fail "$errors smoke test(s) failed"
     exit 1