eagle-mem 2.0.7 → 3.0.0

package/bin/eagle-mem

@@ -27,6 +27,9 @@ case "$command" in
     refresh)    bash "$SCRIPTS_DIR/refresh.sh" "$@" ;;
     prune)      bash "$SCRIPTS_DIR/prune.sh" "$@" ;;
     memories)   bash "$SCRIPTS_DIR/memories.sh" "$@" ;;
+    config)     bash "$SCRIPTS_DIR/config.sh" "$@" ;;
+    curate)     bash "$SCRIPTS_DIR/curate.sh" "$@" ;;
+    feature)    bash "$SCRIPTS_DIR/feature.sh" "$@" ;;
     help|--help|-h)
                 bash "$SCRIPTS_DIR/help.sh" ;;
     version|--version|-v|-V)

package/db/013_features.sql

@@ -0,0 +1,69 @@
+-- Migration 013: Feature graph for deployment regression prevention
+-- Features are persistent entities with lifecycle, dependencies, files, and smoke tests.
+-- Auto-discovered by curator from accumulated session data (tasks, key_files, decisions).
+
+CREATE TABLE IF NOT EXISTS features (
+    id INTEGER PRIMARY KEY,
+    project TEXT NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT,
+    status TEXT DEFAULT 'active',
+    last_verified_at TIMESTAMP,
+    last_verified_notes TEXT,
+    created_at TIMESTAMP DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TIMESTAMP DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE(project, name)
+);
+
+CREATE TABLE IF NOT EXISTS feature_dependencies (
+    id INTEGER PRIMARY KEY,
+    feature_id INTEGER NOT NULL,
+    kind TEXT NOT NULL,
+    target TEXT NOT NULL,
+    name TEXT NOT NULL,
+    notes TEXT,
+    FOREIGN KEY (feature_id) REFERENCES features(id) ON DELETE CASCADE,
+    UNIQUE(feature_id, kind, target, name)
+);
+
+CREATE TABLE IF NOT EXISTS feature_files (
+    id INTEGER PRIMARY KEY,
+    feature_id INTEGER NOT NULL,
+    file_path TEXT NOT NULL,
+    role TEXT,
+    FOREIGN KEY (feature_id) REFERENCES features(id) ON DELETE CASCADE,
+    UNIQUE(feature_id, file_path)
+);
+
+CREATE TABLE IF NOT EXISTS feature_smoke_tests (
+    id INTEGER PRIMARY KEY,
+    feature_id INTEGER NOT NULL,
+    command TEXT NOT NULL,
+    description TEXT,
+    FOREIGN KEY (feature_id) REFERENCES features(id) ON DELETE CASCADE
+);
+
+-- FTS5 for feature search
+CREATE VIRTUAL TABLE IF NOT EXISTS features_fts USING fts5(
+    name,
+    description,
+    content='features',
+    content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS features_ai AFTER INSERT ON features BEGIN
+    INSERT INTO features_fts(rowid, name, description)
+    VALUES (new.id, new.name, new.description);
+END;
+
+CREATE TRIGGER IF NOT EXISTS features_ad AFTER DELETE ON features BEGIN
+    INSERT INTO features_fts(features_fts, rowid, name, description)
+    VALUES ('delete', old.id, old.name, old.description);
+END;
+
+CREATE TRIGGER IF NOT EXISTS features_au AFTER UPDATE ON features BEGIN
+    INSERT INTO features_fts(features_fts, rowid, name, description)
+    VALUES ('delete', old.id, old.name, old.description);
+    INSERT INTO features_fts(rowid, name, description)
+    VALUES (new.id, new.name, new.description);
+END;

package/db/014_command_intelligence.sql

@@ -0,0 +1,25 @@
+-- Migration 014: Command intelligence — output size tracking + command rules
+-- Adds output metrics to observations for adaptive command filtering.
+
+ALTER TABLE observations ADD COLUMN output_bytes INTEGER;
+ALTER TABLE observations ADD COLUMN output_lines INTEGER;
+ALTER TABLE observations ADD COLUMN command_category TEXT;
+
+-- Command rules table — populated by curator, consumed by PreToolUse hook
+CREATE TABLE IF NOT EXISTS command_rules (
+    id INTEGER PRIMARY KEY,
+    project TEXT,
+    pattern TEXT NOT NULL,
+    strategy TEXT NOT NULL DEFAULT 'summary',
+    max_lines INTEGER,
+    reason TEXT,
+    times_seen INTEGER DEFAULT 0,
+    avg_output_bytes INTEGER DEFAULT 0,
+    enabled INTEGER DEFAULT 1,
+    created_at TIMESTAMP DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TIMESTAMP DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE(project, pattern)
+);
+
+CREATE INDEX IF NOT EXISTS idx_command_rules_pattern ON command_rules(pattern);
+CREATE INDEX IF NOT EXISTS idx_observations_category ON observations(command_category);

package/hooks/post-tool-use.sh

@@ -34,6 +34,9 @@ project=$(eagle_project_from_cwd "$cwd")
 files_read="[]"
 files_modified="[]"
 tool_summary=""
+output_bytes=""
+output_lines=""
+command_category=""
 
 case "$tool_name" in
     Read)
@@ -53,24 +56,34 @@ case "$tool_name" in
         ;;
     Bash)
         cmd=$(echo "$input" | jq -r '.tool_input.command // empty' | cut -c1-200)
-        # Redact common secret patterns before storing
-        cmd=$(echo "$cmd" | sed -E \
-            -e 's/(Bearer )[^ ]*/\1[REDACTED]/gi' \
-            -e 's/(api[_-]?key[= :])[^ ]*/\1[REDACTED]/gi' \
-            -e 's/(password[= :])[^ ]*/\1[REDACTED]/gi' \
-            -e 's/(secret[= :])[^ ]*/\1[REDACTED]/gi' \
-            -e 's/(token[= :])[^ ]*/\1[REDACTED]/gi' \
-            -e 's/(Authorization: )[^ ]*/\1[REDACTED]/gi' \
-            -e 's/sk_live_[A-Za-z0-9]+/[REDACTED]/g' \
-            -e 's/sk_test_[A-Za-z0-9]+/[REDACTED]/g' \
-            -e 's/AKIA[A-Z0-9]{16}/[REDACTED]/g' \
-            -e 's/ghp_[A-Za-z0-9]{36}/[REDACTED]/g' \
-            -e 's/gho_[A-Za-z0-9]{36}/[REDACTED]/g' \
-            -e 's/sk-ant-[A-Za-z0-9_-]+/[REDACTED]/g' \
-            -e 's/sk-[A-Za-z0-9]{20,}/[REDACTED]/g' \
-            -e 's/(ANTHROPIC_API_KEY[= :])[^ ]*/\1[REDACTED]/g' \
-            -e 's/(OPENAI_API_KEY[= :])[^ ]*/\1[REDACTED]/g')
+        cmd=$(echo "$cmd" | eagle_redact)
         tool_summary="Bash: $cmd"
+
+        # Output metrics
+        tool_output=$(echo "$input" | jq -r '.tool_result.stdout // empty' 2>/dev/null)
+        if [ -n "$tool_output" ]; then
+            output_bytes=${#tool_output}
+            output_lines=$(echo "$tool_output" | wc -l | tr -d ' ')
+        fi
+
+        # Command category extraction
+        first_word=$(echo "$cmd" | awk '{print $1}' | sed 's|.*/||')
+        case "$first_word" in
+            git|gh) command_category="git" ;;
+            npm|npx|pnpm|yarn|bun) command_category="js" ;;
+            pip|pip3|python|python3|uv) command_category="python" ;;
+            cargo|rustc) command_category="rust" ;;
+            go) command_category="go" ;;
+            docker|docker-compose|podman) command_category="docker" ;;
+            kubectl|helm|k9s) command_category="k8s" ;;
+            aws|gcloud|az) command_category="cloud" ;;
+            make|cmake|ninja) command_category="build" ;;
+            grep|find|ls|cat|head|tail|wc|sort|sed|awk) command_category="files" ;;
+            curl|wget|http) command_category="http" ;;
+            *test*|jest|pytest|vitest|mocha) command_category="test" ;;
+            *lint*|eslint|ruff|golangci-lint) command_category="lint" ;;
+            *) command_category="other" ;;
+        esac
         ;;
     TaskCreate|TaskUpdate)
         task_subject=$(echo "$input" | jq -r '.tool_input.subject // empty')
@@ -158,6 +171,72 @@ case "$tool_name" in
         ;;
 esac
 
-eagle_insert_observation "$session_id" "$project" "$tool_name" "$tool_summary" "$files_read" "$files_modified"
+# ─── Decision + feature surfacing on Read ──────────────────
+# When Claude reads a file, surface past decisions and feature pipeline context.
+case "$tool_name" in
+    Read)
+        if [ -n "$fp" ]; then
+            fname=$(basename "$fp")
+            fname_stem="${fname%.*}"
+            read_context=""
+            case "$fp" in
+                "$HOME/.claude/"*) ;; # skip Claude config files
+                *)
+                    p_esc=$(eagle_sql_escape "$project")
+
+                    # Decision history from summaries
+                    if [ ${#fname_stem} -ge 3 ]; then
+                        fts_query=$(eagle_fts_sanitize "$fname_stem")
+                        if [ -n "$fts_query" ]; then
+                            fts_esc=$(eagle_sql_escape "$fts_query")
+                            decision_hit=$(eagle_db "SELECT s.decisions
+                                FROM summaries s
+                                JOIN summaries_fts f ON f.rowid = s.id
+                                WHERE summaries_fts MATCH '$fts_esc'
+                                AND s.project = '$p_esc'
+                                AND s.decisions IS NOT NULL
+                                AND s.decisions != ''
+                                ORDER BY s.created_at DESC
+                                LIMIT 1;")
+                            if [ -n "$decision_hit" ]; then
+                                read_context+="Eagle Mem decision history for '${fname}': ${decision_hit} — Do not revert without explicit user request. "
+                            fi
+                        fi
+                    fi
+
+                    # Feature pipeline context
+                    feature_hit=$(eagle_find_features_for_file "$project" "$fp")
+                    if [ -n "$feature_hit" ]; then
+                        while IFS='|' read -r feat_name feat_desc feat_verified _role feat_deps feat_other_files feat_smoke; do
+                            [ -z "$feat_name" ] && continue
+                            read_context+="Eagle Mem: '${fname}' is part of feature '${feat_name}'"
+                            [ -n "$feat_desc" ] && read_context+=" ($feat_desc)"
+                            read_context+="."
+                            if [ -n "$feat_verified" ]; then
+                                read_context+=" Last verified: ${feat_verified}."
+                            fi
+                            if [ -n "$feat_deps" ]; then
+                                read_context+=" Dependencies: ${feat_deps}."
+                            fi
+                            if [ -n "$feat_other_files" ]; then
+                                read_context+=" Other files in pipeline: ${feat_other_files}."
+                            fi
+                            if [ -n "$feat_smoke" ]; then
+                                read_context+=" Smoke tests: ${feat_smoke}."
+                            fi
+                            read_context+=" Changes require re-testing after deploy. "
+                        done <<< "$feature_hit"
+                    fi
+
+                    if [ -n "$read_context" ]; then
+                        jq -nc --arg ctx "$read_context" '{"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":$ctx}}'
+                    fi
+                    ;;
+            esac
+        fi
+        ;;
+esac
+
+eagle_insert_observation "$session_id" "$project" "$tool_name" "$tool_summary" "$files_read" "$files_modified" "$output_bytes" "$output_lines" "$command_category"
 
 exit 0

package/hooks/pre-tool-use.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — PreToolUse hook
+# Fires before every Bash tool use
+# 1. Surfaces feature verification checklists before git push
+# 2. Applies learned command filtering rules (RTK-style adaptive)
+# ═══════════════════════════════════════════════════════════
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPT_DIR/../lib"
+
+. "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
+
+input=$(eagle_read_stdin)
+[ -z "$input" ] && exit 0
+
+tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+[ "$tool_name" != "Bash" ] && exit 0
+
+[ ! -f "$EAGLE_MEM_DB" ] && exit 0
+
+cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
+[ -z "$cmd" ] && exit 0
+
+session_id=$(echo "$input" | jq -r '.session_id // empty')
+cwd=$(echo "$input" | jq -r '.cwd // empty')
+project=$(eagle_project_from_cwd "$cwd")
+p_esc=$(eagle_sql_escape "$project")
+
+context=""
+
+# ─── Feature verification on git push ─────────────────────
+
+case "$cmd" in
+    *"git push"*|*"gh pr create"*)
+        has_features=$(eagle_db "SELECT COUNT(*) FROM features WHERE project = '$p_esc' AND status = 'active';")
+        if [ "${has_features:-0}" -gt 0 ]; then
+            changed_files=""
+            if [ -n "$cwd" ] && [ -d "$cwd" ]; then
+                changed_files=$(git -C "$cwd" diff --name-only HEAD 2>/dev/null)
+                [ -z "$changed_files" ] && changed_files=$(git -C "$cwd" diff --cached --name-only 2>/dev/null)
+            fi
+
+            if [ -n "$changed_files" ]; then
+                seen_features=""
+                while IFS= read -r changed_file; do
+                    [ -z "$changed_file" ] && continue
+                    fname=$(basename "$changed_file")
+                    fname_esc=$(eagle_sql_escape "$fname")
+
+                    feature_hits=$(eagle_db "SELECT DISTINCT f.name,
+                        (SELECT GROUP_CONCAT(fst.command, '; ')
+                         FROM feature_smoke_tests fst WHERE fst.feature_id = f.id) as smoke,
+                        (SELECT GROUP_CONCAT(fd.target || ':' || fd.name, ', ')
+                         FROM feature_dependencies fd WHERE fd.feature_id = f.id) as deps,
+                        f.last_verified_at
+                        FROM features f
+                        JOIN feature_files ff ON ff.feature_id = f.id
+                        WHERE f.project = '$p_esc'
+                        AND f.status = 'active'
+                        AND (ff.file_path LIKE '%$fname_esc' OR ff.file_path LIKE '%$fname_esc%');")
+
+                    while IFS='|' read -r feat_name feat_smoke feat_deps feat_verified; do
+                        [ -z "$feat_name" ] && continue
+                        case "$seen_features" in *"|$feat_name|"*) continue ;; esac
+                        seen_features+="|$feat_name|"
+
+                        context+="  - $feat_name"
+                        [ -n "$feat_smoke" ] && context+=" | smoke: $feat_smoke"
+                        [ -n "$feat_deps" ] && context+=" | deps: $feat_deps"
+                        if [ -n "$feat_verified" ]; then
+                            context+=" | last verified: $feat_verified"
+                        else
+                            context+=" | never verified"
+                        fi
+                        context+=$'\n'
+                    done <<< "$feature_hits"
+                done <<< "$changed_files"
+
+                if [ -n "$context" ]; then
+                    context="Eagle Mem: This push affects the following features. After deploy, verify each works and run 'eagle-mem feature verify <name>'.
+${context}"
+                fi
+            fi
+        fi
+        ;;
+esac
+
+# ─── Command output filtering (learned rules) ─────────────
+
+# Extract the base command for rule matching
+base_cmd=$(echo "$cmd" | awk '{print $1}' | sed 's|.*/||')
+cmd_esc=$(eagle_sql_escape "$base_cmd")
+
+rule=$(eagle_db "SELECT strategy, max_lines, reason
+    FROM command_rules
+    WHERE enabled = 1
+    AND (project = '$p_esc' OR project IS NULL)
+    AND ('$cmd_esc' LIKE pattern OR '$cmd_esc' = pattern)
+    ORDER BY
+        CASE WHEN project IS NOT NULL THEN 0 ELSE 1 END
+    LIMIT 1;")
+
+if [ -n "$rule" ]; then
+    IFS='|' read -r strategy max_lines reason <<< "$rule"
+    case "$strategy" in
+        summary)
+            context+="Eagle Mem command hint: '${base_cmd}' output is typically noisy (${reason}). Consider piping through 'tail -5' or checking exit code only."
+            ;;
+        truncate)
+            if [ -n "$max_lines" ] && [ "$max_lines" -gt 0 ] 2>/dev/null; then
+                context+="Eagle Mem command hint: '${base_cmd}' produces long output (${reason}). Consider: ${cmd} | head -${max_lines}"
+            fi
+            ;;
+    esac
+fi
+
+[ -z "$context" ] && exit 0
+
+jq -nc --arg ctx "$context" '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":$ctx}}'
+
+exit 0

package/hooks/session-start.sh

@@ -268,6 +268,10 @@ $eagle_banner
 
 This gives the user visibility into the full context Eagle Mem loaded for this session.
 
+ANTI-REGRESSION: When Eagle Mem surfaces decision history about a file you are reading (via PostToolUse context), those decisions were made deliberately in past sessions. Do NOT revert or change the implementation approach without explicit user request. If you believe a past decision should change, state why and ask the user before proceeding. This prevents the common regression where Claude 'improves' code back to an older approach that was already rejected.
+
+SECRET SAFETY: Never include raw API keys, tokens, passwords, or secrets in eagle-summary fields or any text that Eagle Mem stores. Reference secrets by name (e.g., 'the Stripe API key', 'GOOGLE_APPLICATION_CREDENTIALS_JSON') not by value. Eagle Mem redacts common patterns automatically, but prevention is better than redaction.
+
 MEMORY FRESHNESS: The memories above include age indicators. If you make a change (edit a file, update a config, change a pattern) that contradicts what a loaded memory says, you MUST update that memory file immediately. Read the memory file, edit it to reflect the new reality, and the PostToolUse hook will sync the update to Eagle Mem. Stale memories mislead future sessions — keeping them current is as important as writing good code.
 
 === EAGLE MEM — SESSION SUMMARY (MANDATORY) ===

package/hooks/stop.sh

@@ -140,6 +140,17 @@ if [ -z "$request" ] && [ -n "$transcript_path" ] && [ -f "$transcript_path" ];
     fi
 fi
 
+# ─── Redact secrets from all text fields before storage ────
+
+request=$(echo "$request" | eagle_redact)
+investigated=$(echo "$investigated" | eagle_redact)
+learned=$(echo "$learned" | eagle_redact)
+completed=$(echo "$completed" | eagle_redact)
+next_steps=$(echo "$next_steps" | eagle_redact)
+decisions=$(echo "$decisions" | eagle_redact)
+gotchas=$(echo "$gotchas" | eagle_redact)
+key_files=$(echo "$key_files" | eagle_redact)
+
 # ─── Write to database ─────────────────────────────────────
 
 if [ -n "$request" ] || [ -n "$completed" ] || [ -n "$learned" ]; then

package/lib/common.sh

@@ -59,6 +59,28 @@ eagle_read_stdin() {
     echo "$input"
 }
 
+# Redact secrets from text before storage.
+# Covers: Bearer tokens, API keys, passwords, secrets, tokens,
+# Stripe/AWS/GitHub/Anthropic/OpenAI key patterns, named env vars.
+eagle_redact() {
+    sed -E \
+        -e 's/(Bearer )[^ ]*/\1[REDACTED]/gi' \
+        -e 's/(api[_-]?key[= :])[^ ]*/\1[REDACTED]/gi' \
+        -e 's/(password[= :])[^ ]*/\1[REDACTED]/gi' \
+        -e 's/(secret[= :])[^ ]*/\1[REDACTED]/gi' \
+        -e 's/(token[= :])[^ ]*/\1[REDACTED]/gi' \
+        -e 's/(Authorization: )[^ ]*/\1[REDACTED]/gi' \
+        -e 's/sk_live_[A-Za-z0-9]+/[REDACTED]/g' \
+        -e 's/sk_test_[A-Za-z0-9]+/[REDACTED]/g' \
+        -e 's/AKIA[A-Z0-9]{16}/[REDACTED]/g' \
+        -e 's/ghp_[A-Za-z0-9]{36}/[REDACTED]/g' \
+        -e 's/gho_[A-Za-z0-9]{36}/[REDACTED]/g' \
+        -e 's/sk-ant-[A-Za-z0-9_-]+/[REDACTED]/g' \
+        -e 's/sk-[A-Za-z0-9]{20,}/[REDACTED]/g' \
+        -e 's/(ANTHROPIC_API_KEY[= :])[^ ]*/\1[REDACTED]/g' \
+        -e 's/(OPENAI_API_KEY[= :])[^ ]*/\1[REDACTED]/g'
+}
+
 # Collect project files into a destination file.
 # Uses git ls-files when available, falls back to find with common exclusions.
 # Usage: eagle_collect_files <target_dir> <output_file>

package/lib/db.sh

@@ -62,9 +62,19 @@ eagle_insert_observation() {
     local tool_input_summary; tool_input_summary=$(eagle_sql_escape "$4")
     local files_read; files_read=$(eagle_sql_escape "$5")
     local files_modified; files_modified=$(eagle_sql_escape "$6")
+    local output_bytes="${7:-}"
+    local output_lines="${8:-}"
+    local command_category; command_category=$(eagle_sql_escape "${9:-}")
+
+    local extra_cols=""
+    local extra_vals=""
+    if [ -n "$output_bytes" ]; then
+        extra_cols=", output_bytes, output_lines, command_category"
+        extra_vals=", $(eagle_sql_int "$output_bytes"), $(eagle_sql_int "$output_lines"), '$command_category'"
+    fi
 
-    eagle_db "INSERT INTO observations (session_id, project, tool_name, tool_input_summary, files_read, files_modified)
-              SELECT '$session_id', '$project', '$tool_name', '$tool_input_summary', '$files_read', '$files_modified'
+    eagle_db "INSERT INTO observations (session_id, project, tool_name, tool_input_summary, files_read, files_modified${extra_cols})
+              SELECT '$session_id', '$project', '$tool_name', '$tool_input_summary', '$files_read', '$files_modified'${extra_vals}
               WHERE NOT EXISTS (
                   SELECT 1 FROM observations
                   WHERE session_id = '$session_id'
@@ -565,3 +575,135 @@ COMMIT;"
     fi
     echo "$removed"
 }
+
+# ─── Feature graph helpers ─────��───────────────────────────
+
+eagle_upsert_feature() {
+    local project; project=$(eagle_sql_escape "$1")
+    local name; name=$(eagle_sql_escape "$2")
+    local description; description=$(eagle_sql_escape "${3:-}")
+
+    eagle_db "INSERT INTO features (project, name, description)
+        VALUES ('$project', '$name', '$description')
+        ON CONFLICT(project, name) DO UPDATE SET
+            description = COALESCE(NULLIF('$description', ''), features.description),
+            updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
+}
+
+eagle_add_feature_dependency() {
+    local feature_id; feature_id=$(eagle_sql_int "$1")
+    local kind; kind=$(eagle_sql_escape "$2")
+    local target; target=$(eagle_sql_escape "$3")
+    local name; name=$(eagle_sql_escape "$4")
+    local notes; notes=$(eagle_sql_escape "${5:-}")
+
+    eagle_db "INSERT OR IGNORE INTO feature_dependencies (feature_id, kind, target, name, notes)
+        VALUES ($feature_id, '$kind', '$target', '$name', '$notes');"
+}
+
+eagle_add_feature_file() {
+    local feature_id; feature_id=$(eagle_sql_int "$1")
+    local file_path; file_path=$(eagle_sql_escape "$2")
+    local role; role=$(eagle_sql_escape "${3:-}")
+
+    eagle_db "INSERT OR IGNORE INTO feature_files (feature_id, file_path, role)
+        VALUES ($feature_id, '$file_path', '$role');"
+}
+
+eagle_add_feature_smoke_test() {
+    local feature_id; feature_id=$(eagle_sql_int "$1")
+    local command; command=$(eagle_sql_escape "$2")
+    local description; description=$(eagle_sql_escape "${3:-}")
+
+    eagle_db "INSERT INTO feature_smoke_tests (feature_id, command, description)
+        VALUES ($feature_id, '$command', '$description');"
+}
+
+eagle_verify_feature() {
+    local project; project=$(eagle_sql_escape "$1")
+    local name; name=$(eagle_sql_escape "$2")
+    local notes; notes=$(eagle_sql_escape "${3:-}")
+
+    eagle_db "UPDATE features SET
+        last_verified_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+        last_verified_notes = '$notes',
+        updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+        WHERE project = '$project' AND name = '$name';"
+}
+
+eagle_get_feature_id() {
+    local project; project=$(eagle_sql_escape "$1")
+    local name; name=$(eagle_sql_escape "$2")
+    eagle_db "SELECT id FROM features WHERE project = '$project' AND name = '$name';"
+}
+
+eagle_list_features() {
+    local project; project=$(eagle_sql_escape "$1")
+    local limit; limit=$(eagle_sql_int "${2:-20}")
+
+    eagle_db "SELECT f.name, f.description, f.status, f.last_verified_at,
+        (SELECT COUNT(*) FROM feature_dependencies WHERE feature_id = f.id) as dep_count,
+        (SELECT COUNT(*) FROM feature_files WHERE feature_id = f.id) as file_count,
+        (SELECT COUNT(*) FROM feature_smoke_tests WHERE feature_id = f.id) as test_count
+        FROM features f
+        WHERE f.project = '$project' AND f.status = 'active'
+        ORDER BY f.updated_at DESC
+        LIMIT $limit;"
+}
+
+eagle_show_feature() {
+    local project; project=$(eagle_sql_escape "$1")
+    local name; name=$(eagle_sql_escape "$2")
+
+    local feature_id
+    feature_id=$(eagle_get_feature_id "$1" "$2")
+    [ -z "$feature_id" ] && return 1
+
+    echo "=== Feature: $2 ==="
+    eagle_db "SELECT name, description, status, last_verified_at, last_verified_notes
+        FROM features WHERE id = $feature_id;"
+
+    local deps
+    deps=$(eagle_db "SELECT kind, target, name, notes FROM feature_dependencies WHERE feature_id = $feature_id;")
+    if [ -n "$deps" ]; then
+        echo "--- Dependencies ---"
+        echo "$deps"
+    fi
+
+    local files
+    files=$(eagle_db "SELECT file_path, role FROM feature_files WHERE feature_id = $feature_id;")
+    if [ -n "$files" ]; then
+        echo "--- Files ---"
+        echo "$files"
+    fi
+
+    local tests
+    tests=$(eagle_db "SELECT command, description FROM feature_smoke_tests WHERE feature_id = $feature_id;")
+    if [ -n "$tests" ]; then
+        echo "--- Smoke Tests ---"
+        echo "$tests"
+    fi
+}
+
+eagle_find_features_for_file() {
+    local project; project=$(eagle_sql_escape "$1")
+    local file_path="$2"
+    local fname; fname=$(basename "$file_path")
+    local fname_esc; fname_esc=$(eagle_sql_escape "$fname")
+
+    eagle_db "SELECT f.name, f.description, f.last_verified_at,
+        ff.role,
+        (SELECT GROUP_CONCAT(fd.target || ':' || fd.name, ', ')
+         FROM feature_dependencies fd WHERE fd.feature_id = f.id) as deps,
+        (SELECT GROUP_CONCAT(ff2.file_path, ', ')
+         FROM feature_files ff2 WHERE ff2.feature_id = f.id AND ff2.file_path != ff.file_path) as other_files,
+        (SELECT GROUP_CONCAT(fst.command, ', ')
+         FROM feature_smoke_tests fst WHERE fst.feature_id = f.id) as smoke_tests
+        FROM features f
+        JOIN feature_files ff ON ff.feature_id = f.id
+        WHERE f.project = '$project'
+        AND f.status = 'active'
+        AND (ff.file_path LIKE '%$fname_esc' OR ff.file_path LIKE '%$fname_esc%')
+        ORDER BY f.updated_at DESC
+        LIMIT 3;"
+}