eagle-mem 4.10.5 → 4.10.6

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.10.6 Graph Memory Rebuild Release
+
+This patch turns the local graph-memory workarounds into supported product behavior:
+
+- **Official Graph Rebuild Path**: Added `eagle-mem graph rebuild` and `eagle-mem index --force` so stale code chunks, declaration nodes, file nodes, and import edges can be rebuilt without manual SQLite deletes.
+- **Graph Node Type Migration**: Added migration `db/038_graph_node_types.sql` to recreate graph node validation triggers with all declaration node types emitted by the indexer: `class`, `struct`, `function`, `func`, `fn`, and `def`.
+- **File-Scoped Declarations**: Declaration nodes now use file-scoped names like `path/to/file.sh::finishDictation`, avoiding collisions when multiple files define the same function/class name.
+- **Dream Cycle Batching**: Replaced per-edge sqlite subprocess calls in session-to-file graph wiring with one batched transaction, and normalized absolute observation paths back to project-relative graph file nodes.
+- **Stale File Filtering**: `eagle_collect_files` now filters deleted-but-tracked paths from `git ls-files`, so scans and rebuilds represent the current filesystem.
+- **Overview Graph Sync**: `eagle-mem overview set` now syncs the graph project node value, keeping graph search aligned with the canonical overview.
+- **Four-Agent Update Surface**: `eagle-mem update` now refreshes Antigravity integrations and Grok skill links in addition to Claude Code and Codex hooks/skills.
+
+---
+
 ## v4.10.5 Hardening Release
 
 This patch release hardens the database architecture, improves CLI usability, and increases programmatic test coverage for all core features:

package/README.md

@@ -161,7 +161,28 @@ Eagle Mem prevents Claude from repeating past mistakes:
 | `eagle-mem test` | Run basic smoke tests for the memory layer |
 | `eagle-mem prune` | Clean old sessions and stale data |
 | `eagle-mem scan` | Scan codebase and generate overview |
-| `eagle-mem index` | Index source files for FTS5 code search |
+| `eagle-mem index` | Index source files for FTS5 code search and static graph declarations |
+| `eagle-mem index --force` | Rebuild current source chunks, declarations, and import edges |
+| `eagle-mem graph rebuild` | Clear and rebuild the current project's code graph and chunks |
+
+### Graph Memory
+
+Graph Memory has two layers:
+
+- `eagle-mem scan --force` refreshes the project overview and file graph from the current working tree.
+- `eagle-mem index --force` rebuilds FTS5 source chunks plus file-scoped declarations and import edges.
+- `eagle-mem graph rebuild` does both code-graph cleanup and forced indexing without requiring manual SQLite deletes.
+
+Useful checks:
+
+```bash
+eagle-mem graph
+eagle-mem graph query EscapeKeyMonitor
+eagle-mem graph neighbors lib/db-graph.sh
+eagle-mem overview set "Current project briefing..."
+```
+
+If graph search shows stale deleted files, run `eagle-mem graph rebuild` from the project root. The rebuild command filters missing tracked paths, clears stale code chunks and declaration nodes, preserves manual overviews, and rewires declarations with file-scoped names such as `apps/mac/DictationController.swift::finishDictation`.
 
 ### Trust and Recovery
 

package/architecture.html

@@ -1294,6 +1294,11 @@
                 <td>Which source files look relevant to this prompt?</td>
                 <td>UserPromptSubmit, index CLI</td>
               </tr>
+              <tr>
+                <td><code>graph_nodes</code>, <code>graph_edges</code>, <code>graph_nodes_fts</code></td>
+                <td>Which files, declarations, sessions, memories, and relationships make up the codebase graph?</td>
+                <td>graph CLI, scan, index, overview set, curator Dream Cycle</td>
+              </tr>
               <tr>
                 <td><code>agent_memories</code>, <code>agent_plans</code>, <code>agent_tasks</code></td>
                 <td>What durable agent artifacts should be shared across Claude Code, Codex, Grok, and Antigravity?</td>
@@ -1316,6 +1321,11 @@
               </tr>
             </tbody>
           </table>
+
+          <div class="callout">
+            <h3>Graph rebuild path</h3>
+            <p><code>eagle-mem graph rebuild</code> is the supported recovery command when graph search shows stale deleted files or stale declarations. It filters missing tracked paths, clears code graph nodes and chunks for the current project, preserves the canonical overview, rewires file nodes, and runs <code>eagle-mem index --force</code> so declarations are file-scoped instead of colliding by bare function name.</p>
+          </div>
         </div>
       </section>
 
@@ -1792,6 +1802,7 @@ eagle-mem install</code></pre>
               <ul>
                 <li><code>lib/common.sh</code> - project detection, agent detection, command parsing, redaction, release command detection.</li>
                 <li><code>lib/db-core.sh</code> and <code>lib/db.sh</code> - SQLite connection setup and module loading.</li>
+                <li><code>lib/db-graph.sh</code> - graph node/edge helpers, code graph rebuild, file path normalization, and Dream Cycle batching.</li>
                 <li><code>lib/db-features.sh</code> - feature lookup, pending verification, verify/waive behavior.</li>
                 <li><code>db/*.sql</code> - schema and migrations for all persistent state.</li>
               </ul>

package/db/036_graph_constraints.sql

@@ -6,16 +6,16 @@
 CREATE TRIGGER IF NOT EXISTS val_graph_nodes_insert BEFORE INSERT ON graph_nodes
 BEGIN
     SELECT CASE
-        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'tag', 'class', 'def')
-        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, tag, class, def')
+        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'tag', 'class', 'struct', 'function', 'func', 'fn', 'def')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, tag, class, struct, function, func, fn, def')
     END;
 END;
 
 CREATE TRIGGER IF NOT EXISTS val_graph_nodes_update BEFORE UPDATE OF node_type ON graph_nodes
 BEGIN
     SELECT CASE
-        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'tag', 'class', 'def')
-        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, tag, class, def')
+        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'tag', 'class', 'struct', 'function', 'func', 'fn', 'def')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, tag, class, struct, function, func, fn, def')
     END;
 END;
 

package/db/038_graph_node_types.sql

@@ -0,0 +1,22 @@
+-- ═══════════════════════════════════════════════════════════
+-- Migration 038: Expand graph node type validation
+-- ═══════════════════════════════════════════════════════════
+
+DROP TRIGGER IF EXISTS val_graph_nodes_insert;
+DROP TRIGGER IF EXISTS val_graph_nodes_update;
+
+CREATE TRIGGER val_graph_nodes_insert BEFORE INSERT ON graph_nodes
+BEGIN
+    SELECT CASE
+        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'tag', 'class', 'struct', 'function', 'func', 'fn', 'def')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, tag, class, struct, function, func, fn, def')
+    END;
+END;
+
+CREATE TRIGGER val_graph_nodes_update BEFORE UPDATE OF node_type ON graph_nodes
+BEGIN
+    SELECT CASE
+        WHEN NEW.node_type NOT IN ('project', 'file', 'feature', 'memory', 'task', 'session', 'tag', 'class', 'struct', 'function', 'func', 'fn', 'def')
+        THEN RAISE(ABORT, 'Data Integrity Error: Invalid node type. Must be one of project, file, feature, memory, task, session, tag, class, struct, function, func, fn, def')
+    END;
+END;

package/lib/common.sh

@@ -1240,7 +1240,12 @@ eagle_collect_files() {
     local output_file="$2"
 
     if git -C "$target_dir" rev-parse --is-inside-work-tree &>/dev/null; then
-        git -C "$target_dir" ls-files --cached --others --exclude-standard > "$output_file"
+        git -C "$target_dir" ls-files --cached --others --exclude-standard \
+            | while IFS= read -r file; do
+                [ -n "$file" ] || continue
+                [ -f "$target_dir/$file" ] || continue
+                printf '%s\n' "$file"
+            done > "$output_file"
     else
         (cd "$target_dir" && find . -type f \
             -not -path '*/node_modules/*' \

package/lib/db-graph.sh

@@ -6,6 +6,66 @@
 [ -n "${_EAGLE_DB_GRAPH_LOADED:-}" ] && return 0
 _EAGLE_DB_GRAPH_LOADED=1
 
+eagle_graph_decl_types_sql() {
+    printf "'class','struct','function','func','fn','def'"
+}
+
+eagle_graph_project_root() {
+    local project="${1:-}"
+    local candidate=""
+
+    case "$project" in
+        /*) candidate="$project" ;;
+        "")
+            candidate="$(pwd)"
+            ;;
+        *)
+            if [ -d "$HOME/$project" ]; then
+                candidate="$HOME/$project"
+            elif [ -d "/$project" ]; then
+                candidate="/$project"
+            else
+                candidate="$(pwd)"
+            fi
+            ;;
+    esac
+
+    (cd "$candidate" 2>/dev/null && pwd) || printf '%s\n' "$candidate"
+}
+
+eagle_graph_normalize_file_path() {
+    local project="${1:-}"
+    local raw="${2:-}"
+    local root="${3:-}"
+
+    raw=$(printf '%s' "$raw" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    raw="${raw#file://}"
+    raw="${raw#./}"
+    [ -z "$raw" ] && return 0
+
+    case "$raw" in
+        "~/"*) raw="$HOME/${raw#~/}" ;;
+    esac
+
+    [ -z "$root" ] && root=$(eagle_graph_project_root "$project")
+    root="${root%/}"
+
+    case "$raw" in
+        "$root"/*) raw="${raw#"$root"/}" ;;
+        "$project"/*) raw="${raw#"$project"/}" ;;
+    esac
+
+    raw="${raw#./}"
+    printf '%s\n' "$raw"
+}
+
+eagle_graph_declaration_node_name() {
+    local file="${1:-}"
+    local declaration="${2:-}"
+    [ -z "$file" ] && { printf '%s\n' "$declaration"; return; }
+    printf '%s::%s\n' "$file" "$declaration"
+}
+
 eagle_graph_add_node() {
     local project; project=$(eagle_sql_escape "$1")
     local node_type; node_type=$(eagle_sql_escape "$2")
@@ -52,6 +112,243 @@ eagle_graph_add_edge() {
             weight = weight + excluded.weight;"
 }
 
+eagle_graph_sync_project_overview() {
+    local project_raw="${1:-}"
+    local overview_raw="${2:-}"
+    [ -n "$project_raw" ] || return 0
+
+    local exists
+    exists=$(eagle_db "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'graph_nodes' LIMIT 1;" 2>/dev/null || true)
+    [ "$exists" = "graph_nodes" ] || return 0
+
+    eagle_graph_add_node "$project_raw" "project" "$project_raw" "$overview_raw" ""
+}
+
+eagle_graph_reset_file_static_edges() {
+    local project_raw="${1:-}"
+    local file_raw="${2:-}"
+    local file_node_id="${3:-}"
+    [ -n "$project_raw" ] && [ -n "$file_raw" ] || return 0
+
+    local project file type_sql
+    project=$(eagle_sql_escape "$project_raw")
+    file=$(eagle_sql_escape "$file_raw")
+    type_sql=$(eagle_graph_decl_types_sql)
+
+    if [ -z "$file_node_id" ]; then
+        file_node_id=$(eagle_graph_get_node_id "$project_raw" "file" "$file_raw")
+    fi
+    if [ -n "$file_node_id" ]; then
+        file_node_id=$(eagle_sql_int "$file_node_id")
+        eagle_db "DELETE FROM graph_edges
+                  WHERE project = '$project'
+                    AND source_node_id = $file_node_id
+                    AND edge_type IN ('declares', 'imports');" >/dev/null
+    fi
+
+    eagle_db "DELETE FROM graph_nodes
+              WHERE project = '$project'
+                AND node_type IN ($type_sql)
+                AND source_path = '$file';" >/dev/null
+}
+
+eagle_graph_clear_index_state() {
+    local project_raw="${1:-}"
+    [ -n "$project_raw" ] || return 0
+
+    local project type_sql
+    project=$(eagle_sql_escape "$project_raw")
+    type_sql=$(eagle_graph_decl_types_sql)
+
+    eagle_db_pipe <<SQL >/dev/null
+BEGIN;
+DELETE FROM code_chunks WHERE project = '$project';
+DELETE FROM graph_edges
+WHERE project = '$project'
+  AND edge_type IN ('declares', 'imports');
+DELETE FROM graph_nodes
+WHERE project = '$project'
+  AND node_type IN ($type_sql);
+COMMIT;
+SQL
+}
+
+eagle_graph_clear_code_state() {
+    local project_raw="${1:-}"
+    [ -n "$project_raw" ] || return 0
+
+    local project type_sql
+    project=$(eagle_sql_escape "$project_raw")
+    type_sql=$(eagle_graph_decl_types_sql)
+
+    eagle_db_pipe <<SQL >/dev/null
+BEGIN;
+DELETE FROM code_chunks WHERE project = '$project';
+DELETE FROM graph_nodes
+WHERE project = '$project'
+  AND node_type IN ('project', 'file', $type_sql);
+COMMIT;
+SQL
+}
+
+eagle_graph_rebuild_codebase() {
+    local project_raw="${1:-}"
+    local target_dir="${2:-.}"
+    [ -n "$project_raw" ] || return 1
+
+    target_dir="$(cd "$target_dir" && pwd)"
+    local tmp_files overview project_node_id file file_node_id file_count
+    tmp_files=$(mktemp)
+    eagle_collect_files "$target_dir" "$tmp_files"
+
+    eagle_graph_clear_code_state "$project_raw"
+
+    overview=""
+    if declare -F eagle_get_overview >/dev/null 2>&1; then
+        overview=$(eagle_get_overview "$project_raw" 2>/dev/null || true)
+    fi
+    eagle_graph_add_node "$project_raw" "project" "$project_raw" "$overview" ""
+    project_node_id=$(eagle_graph_get_node_id "$project_raw" "project" "$project_raw")
+
+    file_count=0
+    if [ -n "$project_node_id" ]; then
+        while IFS= read -r file; do
+            [ -n "$file" ] || continue
+            [ -f "$target_dir/$file" ] || continue
+            eagle_graph_add_node "$project_raw" "file" "$file" "" "$target_dir/$file"
+            file_node_id=$(eagle_graph_get_node_id "$project_raw" "file" "$file")
+            if [ -n "$file_node_id" ]; then
+                eagle_graph_add_edge "$project_raw" "$project_node_id" "$file_node_id" "contains" 1.0 >/dev/null || true
+            fi
+            file_count=$((file_count + 1))
+        done < "$tmp_files"
+    fi
+
+    rm -f "$tmp_files"
+    printf '%s\n' "$file_count"
+}
+
+eagle_graph_wire_recent_session_edges() {
+    local project_raw="${1:-}"
+    local limit="${2:-15}"
+    [ -n "$project_raw" ] || { printf '0\n'; return 0; }
+    if ! [[ "$limit" =~ ^[0-9]+$ ]] || [ "$limit" -lt 1 ]; then
+        limit=15
+    fi
+
+    local project rows session_count root sql_file
+    project=$(eagle_sql_escape "$project_raw")
+    rows=$(eagle_db_json "WITH recent_sessions AS (
+              SELECT id, started_at, model
+              FROM sessions
+              WHERE project = '$project'
+              ORDER BY started_at DESC
+              LIMIT $limit
+          )
+          SELECT r.id AS session_id,
+                 r.started_at AS started_at,
+                 r.model AS model,
+                 COALESCE(o.files_read, '[]') AS files_read,
+                 COALESCE(o.files_modified, '[]') AS files_modified
+          FROM recent_sessions r
+          LEFT JOIN observations o ON o.session_id = r.id
+          ORDER BY r.started_at DESC;" 2>/dev/null || true)
+
+    if [ -z "$rows" ] || [ "$rows" = "[]" ]; then
+        printf '0\n'
+        return 0
+    fi
+
+    session_count=$(printf '%s' "$rows" | jq -r '.[].session_id // empty' 2>/dev/null | sort -u | wc -l | tr -d ' ')
+    root=$(eagle_graph_project_root "$project_raw")
+    sql_file=$(mktemp)
+
+    {
+        echo "BEGIN;"
+        printf '%s' "$rows" | jq -c '.[]' 2>/dev/null | while IFS= read -r row; do
+            local sid started model sid_sql value_sql
+            sid=$(printf '%s' "$row" | jq -r '.session_id // empty')
+            [ -n "$sid" ] || continue
+            started=$(printf '%s' "$row" | jq -r '.started_at // "unknown"')
+            model=$(printf '%s' "$row" | jq -r '.model // "unknown"')
+            sid_sql=$(eagle_sql_escape "$sid")
+            value_sql=$(eagle_sql_escape "Session run on $started using $model")
+
+            cat <<SQL
+INSERT INTO graph_nodes (project, node_type, node_name, node_value, source_path)
+VALUES ('$project', 'session', '$sid_sql', '$value_sql', '')
+ON CONFLICT(project, node_type, node_name) DO UPDATE SET
+    node_value = excluded.node_value,
+    updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');
+SQL
+
+            printf '%s' "$row" | jq -r '.files_read | if type == "string" then (try fromjson catch []) else (. // []) end | .[]?' 2>/dev/null \
+                | while IFS= read -r file_path; do
+                    [ -n "$file_path" ] || continue
+                    eagle_graph_emit_session_file_edge_sql "$project_raw" "$sid" "$file_path" "$root" "read" "1.0"
+                done
+            printf '%s' "$row" | jq -r '.files_modified | if type == "string" then (try fromjson catch []) else (. // []) end | .[]?' 2>/dev/null \
+                | while IFS= read -r file_path; do
+                    [ -n "$file_path" ] || continue
+                    eagle_graph_emit_session_file_edge_sql "$project_raw" "$sid" "$file_path" "$root" "modified" "2.0"
+                done
+        done
+        echo "COMMIT;"
+    } > "$sql_file"
+
+    eagle_db_pipe < "$sql_file" >/dev/null
+    rm -f "$sql_file"
+    printf '%s\n' "${session_count:-0}"
+}
+
+eagle_graph_emit_session_file_edge_sql() {
+    local project_raw="${1:-}"
+    local session_id="${2:-}"
+    local file_path="${3:-}"
+    local root="${4:-}"
+    local edge_type="${5:-read}"
+    local weight="${6:-1.0}"
+    local normalized project sid file edge
+
+    normalized=$(eagle_graph_normalize_file_path "$project_raw" "$file_path" "$root")
+    [ -n "$normalized" ] || return 0
+
+    project=$(eagle_sql_escape "$project_raw")
+    sid=$(eagle_sql_escape "$session_id")
+    file=$(eagle_sql_escape "$normalized")
+    edge=$(eagle_sql_escape "$edge_type")
+    if ! [[ "$weight" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
+        weight="1.0"
+    fi
+
+    cat <<SQL
+INSERT OR IGNORE INTO graph_edges (project, source_node_id, target_node_id, edge_type, weight)
+SELECT '$project', s.id, f.id, '$edge', 0.0
+FROM graph_nodes s, graph_nodes f
+WHERE s.project = '$project'
+  AND s.node_type = 'session'
+  AND s.node_name = '$sid'
+  AND f.project = '$project'
+  AND f.node_type = 'file'
+  AND f.node_name = '$file'
+  AND s.id != f.id;
+UPDATE graph_edges
+SET weight = weight + $weight
+WHERE project = '$project'
+  AND edge_type = '$edge'
+  AND source_node_id = (
+      SELECT id FROM graph_nodes
+      WHERE project = '$project' AND node_type = 'session' AND node_name = '$sid'
+      LIMIT 1
+  )
+  AND target_node_id = (
+      SELECT id FROM graph_nodes
+      WHERE project = '$project' AND node_type = 'file' AND node_name = '$file'
+      LIMIT 1
+  );
+SQL
+}
+
 eagle_graph_query_neighbors() {
     local node_id; node_id=$(eagle_sql_int "$1")
     local direction="${2:-out}" # 'out', 'in', or 'both'
@@ -124,14 +421,24 @@ eagle_graph_delete_node() {
 
 eagle_graph_prune_orphans() {
     local project; project=$(eagle_sql_escape "$1")
+    local target_dir="${2:-}"
+    [ -n "$target_dir" ] && target_dir="${target_dir%/}"
     # Delete file nodes that no longer exist on disk
     local result
-    result=$(eagle_db "SELECT id, node_name FROM graph_nodes WHERE project = '$project' AND node_type = 'file';")
+    result=$(eagle_db "SELECT id, node_name, COALESCE(source_path, '') FROM graph_nodes WHERE project = '$project' AND node_type = 'file';")
     [ -z "$result" ] && return 0
 
-    while IFS='|' read -r nid nname; do
+    while IFS='|' read -r nid nname nsource; do
         [ -z "$nid" ] && continue
-        if [ ! -f "$nname" ]; then
+        local candidate="$nsource"
+        if [ -z "$candidate" ]; then
+            if [ -n "$target_dir" ]; then
+                candidate="$target_dir/$nname"
+            else
+                candidate="$nname"
+            fi
+        fi
+        if [ ! -f "$candidate" ]; then
             eagle_graph_delete_node "$nid"
         fi
     done <<< "$result"

package/lib/db-summaries.sh

@@ -124,6 +124,10 @@ eagle_upsert_overview() {
                   content = excluded.content,
                   source = excluded.source,
                   updated_at = excluded.updated_at;"
+
+    if declare -F eagle_graph_sync_project_overview >/dev/null 2>&1; then
+        eagle_graph_sync_project_overview "$1" "$raw_content" || true
+    fi
 }
 
 eagle_get_overview_source() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "4.10.5",
+  "version": "4.10.6",
   "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"
@@ -12,9 +12,11 @@
     "lib/",
     "db/",
     "skills/",
+    "tests/*.py",
+    "tests/*.sh",
     "docs/",
     "architecture.html",
-    "integrations/",
+    "integrations/*.py",
     "CHANGELOG.md"
   ],
   "keywords": [

package/scripts/curate.sh

@@ -563,41 +563,12 @@ if [ -n "$co_edit_data" ]; then
 fi
 
 # 7.2 Wire session nodes and access edges
-recent_sessions=$(eagle_db "SELECT id, started_at, model FROM sessions WHERE project = '$p_esc' ORDER BY started_at DESC LIMIT 15;")
+recent_sessions=$(eagle_db "SELECT id FROM sessions WHERE project = '$p_esc' ORDER BY started_at DESC LIMIT 15;")
 if [ -n "$recent_sessions" ]; then
-    session_wire_count=0
-    while IFS='|' read -r sid sstart smodel; do
-        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")
-            if [ -n "$sid_node" ]; then
-                # Find read/modified files in this session from observations
-                session_files=$(eagle_db "SELECT files_read, files_modified FROM observations WHERE session_id = '$(eagle_sql_escape "$sid")';")
-                if [ -n "$session_files" ]; then
-                    while IFS='|' read -r f_read f_mod; do
-                        # Parse files_read JSON list
-                        if [ -n "$f_read" ] && [ "$f_read" != "[]" ]; then
-                            echo "$f_read" | grep -oE '"[^"]+"' | tr -d '"' | while read -r rf; do
-                                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
-                        fi
-                        # Parse files_modified JSON list
-                        if [ -n "$f_mod" ] && [ "$f_mod" != "[]" ]; then
-                            echo "$f_mod" | grep -oE '"[^"]+"' | tr -d '"' | while read -r mf; do
-                                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
-                        fi
-                    done <<< "$session_files"
-                fi
-            fi
-        fi
-        session_wire_count=$((session_wire_count + 1))
-    done <<< "$recent_sessions"
+    session_wire_count=$(printf '%s\n' "$recent_sessions" | awk 'NF {count++} END {print count + 0}')
+    if [ "$DRY_RUN" -eq 0 ]; then
+        session_wire_count=$(eagle_graph_wire_recent_session_edges "$project" 15)
+    fi
     eagle_ok "Wired $session_wire_count recent session nodes and edges"
 fi
 

package/scripts/help.sh

@@ -14,7 +14,7 @@ eagle_banner
 
 echo -e "  ${BOLD}Eagle Mem${RESET} ${DIM}v${version}${RESET}"
 echo -e "  ${DIM}Shared memory, release guardrails, RTK token protection, and worker lanes${RESET}"
-echo -e "  ${DIM}for Claude Code, Codex, and Grok.${RESET}"
+echo -e "  ${DIM}for Claude Code, Codex, Grok, and Google Antigravity.${RESET}"
 echo ""
 echo -e "  ${BOLD}Core commands:${RESET}"
 echo -e "    ${CYAN}install${RESET}     First-time setup: hooks, database, skills"
@@ -28,6 +28,7 @@ echo -e "    ${CYAN}overview${RESET}    Build or view project overview"
 echo -e "    ${CYAN}session${RESET}     Save a manual session summary"
 echo -e "    ${CYAN}memories${RESET}    View/sync agent memories"
 echo -e "    ${CYAN}tasks${RESET}       View mirrored tasks"
+echo -e "    ${CYAN}graph${RESET}       View, query, or rebuild the codebase knowledge graph"
 echo ""
 echo -e "  ${BOLD}Safety and token controls:${RESET}"
 echo -e "    ${CYAN}feature${RESET}       Track, verify, and unblock feature changes"
@@ -59,6 +60,8 @@ echo -e "    ${DIM}\$${RESET} eagle-mem search --tasks        ${DIM}# in-flight
 echo -e "    ${DIM}\$${RESET} eagle-mem search --files        ${DIM}# hot files${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem search --stats        ${DIM}# project stats${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem session save --summary \"fixed auth\""
+echo -e "    ${DIM}\$${RESET} eagle-mem graph rebuild       ${DIM}# rebuild code graph + chunks${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem index --force       ${DIM}# force source chunk/declaration indexing${RESET}"
 echo ""
 echo -e "  ${BOLD}Anti-regression:${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem feature pending       ${DIM}# pending release blockers${RESET}"

package/scripts/index.sh

@@ -15,7 +15,28 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 
 eagle_ensure_db
 
-TARGET_DIR="${1:-.}"
+force=false
+args=()
+
+show_help() {
+    echo -e "  ${BOLD}eagle-mem index${RESET} — Index source files and wire code graph declarations"
+    echo ""
+    echo -e "  ${BOLD}Usage:${RESET}"
+    echo -e "    eagle-mem index [path]              ${DIM}# incrementally index changed files${RESET}"
+    echo -e "    eagle-mem index ${CYAN}--force${RESET} [path]      ${DIM}# rebuild chunks and static code graph edges${RESET}"
+    echo ""
+    exit 0
+}
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --force|-f) force=true; shift ;;
+        --help|-h) show_help ;;
+        *) args+=("$1"); shift ;;
+    esac
+done
+
+TARGET_DIR="${args[0]:-.}"
 TARGET_DIR="$(cd "$TARGET_DIR" && pwd)"
 PROJECT=$(eagle_project_from_cwd "$TARGET_DIR")
 
@@ -106,10 +127,20 @@ NEEDS_INDEX="$TMPDIR_IDX/needs_index"
 
 skipped_count=0
 
+if [ "$force" = true ]; then
+    eagle_info "Force rebuild requested: clearing chunks, declarations, and import edges"
+    eagle_graph_clear_index_state "$PROJECT"
+fi
+
 while IFS= read -r file; do
     full_path="$TARGET_DIR/$file"
     current_mtime=$(stat -f '%m' "$full_path" 2>/dev/null || stat -c '%Y' "$full_path" 2>/dev/null || echo "0")
 
+    if [ "$force" = true ]; then
+        echo "$file"
+        continue
+    fi
+
     stored_mtime=$(eagle_db "SELECT MAX(mtime) FROM code_chunks WHERE project = '$project_sql' AND file_path = '$(eagle_sql_escape "$file")';")
 
     if [ -n "$stored_mtime" ] && [ "$stored_mtime" = "$current_mtime" ]; then
@@ -180,16 +211,26 @@ COMMIT;"
 
     # Static syntax relation extraction & graph wiring
     # Wire node & edge static parser
+    overview=$(eagle_get_overview "$PROJECT" 2>/dev/null || true)
+    eagle_graph_add_node "$PROJECT" "project" "$PROJECT" "$overview" ""
+    project_node_id=$(eagle_graph_get_node_id "$PROJECT" "project" "$PROJECT")
+    eagle_graph_add_node "$PROJECT" "file" "$file" "" "$full_path"
     file_node_id=$(eagle_graph_get_node_id "$PROJECT" "file" "$file")
     if [ -n "$file_node_id" ]; then
+        if [ -n "$project_node_id" ]; then
+            eagle_graph_add_edge "$PROJECT" "$project_node_id" "$file_node_id" "contains" 1.0 >/dev/null || true
+        fi
+        eagle_graph_reset_file_static_edges "$PROJECT" "$file" "$file_node_id"
+
         # 1. Parse function/class declarations
         # e.g., "def name", "class name", "fn name", "function name", "func name"
         declarations=$(grep -oE '\<(class|struct|function|def|fn|func)[[:space:]]+[A-Za-z0-9_]+' "$full_path" 2>/dev/null | awk '{print $1 ":" $2}' | sort -u || true)
         if [ -n "$declarations" ]; then
             while IFS=':' read -r dtype dname; do
                 [ -z "$dname" ] && continue
-                eagle_graph_add_node "$PROJECT" "$dtype" "$dname" "Declared in $file" "$file"
-                decl_node_id=$(eagle_graph_get_node_id "$PROJECT" "$dtype" "$dname")
+                decl_node_name=$(eagle_graph_declaration_node_name "$file" "$dname")
+                eagle_graph_add_node "$PROJECT" "$dtype" "$decl_node_name" "Declared $dname in $file" "$file"
+                decl_node_id=$(eagle_graph_get_node_id "$PROJECT" "$dtype" "$decl_node_name")
                 if [ -n "$decl_node_id" ]; then
                     eagle_graph_add_edge "$PROJECT" "$file_node_id" "$decl_node_id" "declares" 1.0
                 fi

package/scripts/memories.sh

@@ -48,6 +48,7 @@ show_help() {
     echo -e "    eagle-mem memories graph                    ${DIM}# view codebase knowledge graph summary${RESET}"
     echo -e "    eagle-mem memories graph query ${CYAN}<term>${RESET}      ${DIM}# search knowledge graph nodes${RESET}"
     echo -e "    eagle-mem memories graph neighbors ${CYAN}<name>${RESET}  ${DIM}# view a node's local network connections${RESET}"
+    echo -e "    eagle-mem memories graph rebuild           ${DIM}# rebuild current project's code graph and chunks${RESET}"
     echo ""
     echo -e "  ${BOLD}Options:${RESET}"
     echo -e "    ${CYAN}-p, --project${RESET} <name>  Filter by project (default: current project)"
@@ -943,6 +944,28 @@ memories_graph() {
             fi
             echo ""
             ;;
+        rebuild)
+            if [ -z "$project" ]; then
+                eagle_err "Cannot determine project for graph rebuild."
+                exit 1
+            fi
+
+            local target_dir file_count
+            target_dir=$(eagle_graph_project_root "$project")
+            if [ ! -d "$target_dir" ]; then
+                target_dir="$(pwd)"
+            fi
+
+            eagle_header "Knowledge Graph Rebuild"
+            eagle_info "Project: $project"
+            eagle_info "Path: $target_dir"
+            echo ""
+
+            file_count=$(eagle_graph_rebuild_codebase "$project" "$target_dir")
+            eagle_ok "Rebuilt file graph ($file_count files)"
+            bash "$SCRIPTS_DIR/index.sh" --force "$target_dir"
+            eagle_footer "Graph rebuild complete."
+            ;;
         summary|*)
             eagle_header "Knowledge Graph Summary"
             echo ""

package/scripts/scan.sh

@@ -210,9 +210,9 @@ detect_framework "mix.exs" "Elixir/Mix" || true
 
 top_dirs=""
 if [ "$is_git" = true ]; then
-    git -C "$TARGET_DIR" ls-files --cached --others --exclude-standard | cut -d/ -f1 | sort -u | while read -r item; do
+    cut -d/ -f1 "$TMPFILE" | sort -u | while read -r item; do
         if [ -d "$TARGET_DIR/$item" ]; then
-            count=$(git -C "$TARGET_DIR" ls-files --cached --others --exclude-standard "$item/" 2>/dev/null | wc -l | tr -d ' ')
+            count=$(grep -c "^$item/" "$TMPFILE" 2>/dev/null || true)
             echo "$item/ ($count)"
         fi
     done > "${TMPFILE}.dirs"
@@ -372,7 +372,7 @@ eagle_graph_add_node "$PROJECT" "project" "$PROJECT" "$overview" ""
 project_node_id=$(eagle_graph_get_node_id "$PROJECT" "project" "$PROJECT")
 
 # Prune deleted/removed files from graph
-eagle_graph_prune_orphans "$PROJECT"
+eagle_graph_prune_orphans "$PROJECT" "$TARGET_DIR"
 
 file_node_count=0
 if [ -n "$project_node_id" ]; then

package/scripts/test.sh

@@ -51,6 +51,7 @@ run_check "Agent Orchestration (orchestrate help)" "\"$EAGLE_BIN\" orchestrate -
 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\""
+run_check "Graph Memory Rebuild (isolated regression suite)" "bash \"$SCRIPTS_DIR/../tests/test_graph_memory.sh\""
 
 echo ""
 if [ "$errors" -eq 0 ]; then
@@ -67,4 +68,4 @@ else
 fi
 
 echo ""
-eagle_info "Run 'eagle-mem test' regularly to guard the memory layer itself."
+eagle_info "Run 'eagle-mem test' regularly to guard the memory layer itself."

package/scripts/update.sh

@@ -20,6 +20,7 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 SETTINGS="$EAGLE_SETTINGS"
 claude_found=false
 codex_found=false
+grok_found=false
 
 eagle_header "Update"
 
@@ -39,18 +40,22 @@ fi
 if [ -d "$EAGLE_CODEX_DIR" ] || command -v codex &>/dev/null; then
     codex_found=true
 fi
+if [ -d "$EAGLE_GROK_DIR" ]; then
+    grok_found=true
+fi
 
 eagle_runtime_change_plan "update" "$PACKAGE_DIR" "$claude_found" "$codex_found"
 
 # ─── Update files ──────────────────────────────────────────
 
-mkdir -p "$EAGLE_MEM_DIR"/{hooks,lib,db,scripts}
+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
 
 chmod +x "$EAGLE_MEM_DIR"/hooks/*.sh
 chmod +x "$EAGLE_MEM_DIR"/db/migrate.sh
@@ -140,6 +145,25 @@ if [ "$codex_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
     eagle_ok "Codex skills updated"
 fi
 
+if [ "$grok_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
+    mkdir -p "$EAGLE_GROK_SKILLS_DIR"
+    find "$EAGLE_GROK_SKILLS_DIR" -maxdepth 1 -name "eagle-mem-*" -type l 2>/dev/null | while read -r existing; do
+        skill_name=$(basename "$existing")
+        if [ ! -d "$PACKAGE_DIR/skills/$skill_name" ]; then
+            rm "$existing"
+            eagle_ok "Removed stale Grok skill: $skill_name"
+        fi
+    done
+    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"
+    done
+    eagle_ok "Grok skills updated"
+fi
+
 # ─── Refresh generated Claude statusline wrapper ───────────
 
 statusline_wrapper="$EAGLE_MEM_DIR/scripts/statusline-wrapper.sh"

package/skills/eagle-mem-memories/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: eagle-mem-memories
 description: >
-  View and sync Claude Code and Codex memories, plans, and tasks mirrored in Eagle Mem. Use when:
+  View and sync Claude Code, Codex, Grok, and Antigravity memories, plans, tasks,
+  and graph memory mirrored in Eagle Mem. Use when:
   'eagle memories', 'show memories', 'sync memories', 'what does the agent remember',
   'show plans', 'show tasks', 'mirror memories', 'onboard project',
   'what did past sessions learn'. Uses the eagle-mem CLI.
@@ -11,9 +12,9 @@ description: >
 
 ## Purpose
 
-**For the user:** Claude Code and Codex remember across sessions. Decisions, preferences, project context, and architectural plans survive session boundaries. The user never has to re-explain "we chose Postgres because..." or "don't use semicolons in this project."
+**For the user:** Claude Code, Codex, Grok, and Antigravity remember across sessions. Decisions, preferences, project context, graph relationships, and architectural plans survive session boundaries. The user never has to re-explain "we chose Postgres because..." or "don't use semicolons in this project."
 
-**For you:** Access to what past Claude Code and Codex sessions learned about this project. Memories tell you *why* decisions were made. Plans tell you *what's coming*. Tasks tell you *what's in flight*. Together they're the knowledge bridge that makes you effective from message one.
+**For you:** Access to what past agent sessions learned about this project. Memories tell you *why* decisions were made. Plans tell you *what's coming*. Tasks tell you *what's in flight*. Graph memory tells you *which files, declarations, and sessions are connected*. Together they're the knowledge bridge that makes you effective from message one.
 
 ## Judgment
 
@@ -64,6 +65,14 @@ eagle-mem memories tasks search "refactor"
 eagle-mem memories tasks show <file_path>
 ```
 
+**Graph memory** -- codebase file nodes, file-scoped declarations, session/file access edges, memory nodes, and relationship edges.
+```bash
+eagle-mem graph                            # graph summary
+eagle-mem graph query "finishDictation"    # search nodes
+eagle-mem graph neighbors "lib/db-graph.sh"
+eagle-mem graph rebuild                    # rebuild stale code graph + chunks
+```
+
 ### 2. Understand how data flows in
 
 Two paths feed the mirror:

package/tests/test_antigravity_hook.py

@@ -0,0 +1,114 @@
+"""
+Mock Unit Test Suite for Native Eagle Mem Google Antigravity Hooks.
+Verifies that all 5 lifecycle hooks run without any errors, trigger appropriate
+asynchronous subprocess mock calls, and correctly output and format findings.
+"""
+
+import os
+import sys
+import asyncio
+import unittest
+
+# Ensure the integrations folder is on the Python path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from integrations.google_antigravity_hook import (
+    EagleMemAntigravityHook,
+    get_session_id,
+    map_tool_name,
+    run_cmd_async,
+    run_hook_async,
+    HAS_ANTIGRAVITY
+)
+
+class MockToolCall:
+    def __init__(self, name, arguments):
+        self.name = name
+        self.arguments = arguments
+
+class MockToolCallResult:
+    def __init__(self, tool_call, output):
+        self.tool_call = tool_call
+        self.output = output
+
+class TestAntigravityHooks(unittest.IsolatedAsyncioTestCase):
+    
+    async def asyncSetUp(self):
+        self.hook = EagleMemAntigravityHook(agent_name="antigravity-test")
+        self.session_id = get_session_id()
+        self.assertTrue(self.session_id.startswith("agy-") or "EAGLE_SESSION_ID" in os.environ)
+        
+    def test_tool_mapping(self):
+        self.assertEqual(map_tool_name("run_command"), "Bash")
+        self.assertEqual(map_tool_name("exec_command"), "Bash")
+        self.assertEqual(map_tool_name("view_file"), "Read")
+        self.assertEqual(map_tool_name("edit_file"), "Edit")
+        self.assertEqual(map_tool_name("create_file"), "Write")
+        self.assertEqual(map_tool_name("custom_tool"), "custom_tool")
+
+    async def test_session_start_hook(self):
+        print("\n--- Testing SessionStart Hook ---")
+        # Run on_session_start. Should trigger native start or fallback search gracefully.
+        try:
+            await self.hook.on_session_start()
+            print("✓ SessionStart executed successfully.")
+        except Exception as e:
+            self.fail(f"on_session_start failed: {e}")
+
+    async def test_pre_tool_call_decide_hook_allow(self):
+        print("\n--- Testing PreToolCallDecide Hook (Allow) ---")
+        tool_call = MockToolCall("run_command", {"CommandLine": "echo 'Hello World'"})
+        result = await self.hook.pre_tool_call_decide(tool_call)
+        self.assertTrue(result.allow)
+        print("✓ PreToolCallDecide (Allow) executed successfully.")
+
+    async def test_pre_tool_call_decide_hook_deny(self):
+        print("\n--- Testing PreToolCallDecide Hook (Deny - Release Boundary) ---")
+        # Under normal conditions, git push might be blocked if features are pending.
+        # Let's verify that the hook runs cleanly when processing git push
+        tool_call = MockToolCall("run_command", {"CommandLine": "git push"})
+        result = await self.hook.pre_tool_call_decide(tool_call)
+        self.assertIn(result.allow, [True, False])
+        print(f"✓ PreToolCallDecide (Deny Check) executed successfully with allow={result.allow}.")
+
+    async def test_post_tool_call_hook(self):
+        print("\n--- Testing PostToolCall Hook ---")
+        tool_call = MockToolCall("run_command", {"CommandLine": "echo 'Test'"})
+        tool_call_result = MockToolCallResult(tool_call, "Test stdout output")
+        try:
+            await self.hook.post_tool_call(tool_call_result)
+            # Give a small slice of time for background tasks to start
+            await asyncio.sleep(0.1)
+            print("✓ PostToolCall executed successfully.")
+        except Exception as e:
+            self.fail(f"post_tool_call failed: {e}")
+
+    async def test_post_turn_hook(self):
+        print("\n--- Testing PostTurn Hook ---")
+        final_response = "I have successfully resolved the issue by editing the configuration files."
+        try:
+            await self.hook.post_turn(final_response)
+            await asyncio.sleep(0.1)
+            print("✓ PostTurn executed successfully.")
+        except Exception as e:
+            self.fail(f"post_turn failed: {e}")
+
+    async def test_compaction_hook(self):
+        print("\n--- Testing Compaction Hook ---")
+        try:
+            await self.hook.on_compaction(data=None)
+            print("✓ Compaction executed successfully.")
+        except Exception as e:
+            self.fail(f"on_compaction failed: {e}")
+
+    async def test_session_end_hook(self):
+        print("\n--- Testing SessionEnd Hook ---")
+        try:
+            await self.hook.on_session_end()
+            await asyncio.sleep(0.1)
+            print("✓ SessionEnd executed successfully.")
+        except Exception as e:
+            self.fail(f"on_session_end failed: {e}")
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_graph_memory.sh

@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+# Focused graph-memory regressions. Runs in an isolated HOME/EAGLE_MEM_DIR.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+EAGLE_BIN="$ROOT_DIR/bin/eagle-mem"
+
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-graph-memory.XXXXXX")
+trap 'rm -rf "$tmp_dir"' EXIT
+
+export HOME="$tmp_dir/home"
+export EAGLE_MEM_DIR="$tmp_dir/eagle-mem"
+mkdir -p "$HOME" "$EAGLE_MEM_DIR"
+
+. "$ROOT_DIR/lib/common.sh"
+"$ROOT_DIR/db/migrate.sh" >/dev/null
+. "$ROOT_DIR/lib/db.sh"
+
+repo="$HOME/project"
+mkdir -p "$repo"
+git -C "$repo" init -q
+git -C "$repo" config user.email "test@example.com"
+git -C "$repo" config user.name "Eagle Mem Test"
+
+cat > "$repo/live.sh" <<'EOF'
+function liveThing() {
+  echo live
+}
+EOF
+
+cat > "$repo/gone.sh" <<'EOF'
+function goneThing() {
+  echo gone
+}
+EOF
+
+git -C "$repo" add live.sh gone.sh
+rm "$repo/gone.sh"
+
+collected="$tmp_dir/files.txt"
+eagle_collect_files "$repo" "$collected"
+grep -qx "live.sh" "$collected"
+if grep -qx "gone.sh" "$collected"; then
+    echo "deleted tracked file was collected" >&2
+    exit 1
+fi
+
+for node_type in func struct function fn def class; do
+    eagle_db "INSERT INTO graph_nodes (project, node_type, node_name)
+              VALUES ('migration-test', '$node_type', '$node_type-node');" >/dev/null
+done
+
+cat > "$repo/a.sh" <<'EOF'
+function finishDictation() {
+  echo a
+}
+EOF
+
+cat > "$repo/b.sh" <<'EOF'
+function finishDictation() {
+  echo b
+}
+EOF
+
+cat > "$repo/old.sh" <<'EOF'
+function CloudDictationPipeline() {
+  echo old
+}
+EOF
+
+git -C "$repo" add a.sh b.sh old.sh
+
+"$EAGLE_BIN" scan --force "$repo" >/dev/null
+"$EAGLE_BIN" index --force "$repo" >/dev/null
+
+decl_count=$(eagle_db "SELECT COUNT(*)
+                       FROM graph_nodes
+                       WHERE project = 'project'
+                         AND node_type = 'function'
+                         AND node_name LIKE '%::finishDictation';")
+if [ "$decl_count" != "2" ]; then
+    echo "expected duplicate declarations to remain file-scoped, got $decl_count" >&2
+    exit 1
+fi
+
+(cd "$repo" && "$EAGLE_BIN" overview set "Fresh offline-only overview" >/dev/null)
+overview_value=$(eagle_db "SELECT node_value
+                           FROM graph_nodes
+                           WHERE project = 'project'
+                             AND node_type = 'project'
+                             AND node_name = 'project'
+                           LIMIT 1;")
+case "$overview_value" in
+    *"Fresh offline-only overview"*) ;;
+    *)
+        echo "overview set did not sync graph project node" >&2
+        exit 1
+        ;;
+esac
+
+eagle_db "INSERT INTO sessions (id, project, cwd, model, status)
+          VALUES ('session-graph-test', 'project', '$repo', 'test-model', 'completed');" >/dev/null
+eagle_db "INSERT INTO observations (session_id, project, tool_name, files_read, files_modified)
+          VALUES ('session-graph-test', 'project', 'Read',
+                  '[\"$repo/a.sh\"]',
+                  '[\"$repo/b.sh\"]');" >/dev/null
+
+eagle_graph_wire_recent_session_edges "project" 15 >/dev/null
+read_edges=$(eagle_db "SELECT COUNT(*)
+                       FROM graph_edges e
+                       JOIN graph_nodes s ON s.id = e.source_node_id
+                       JOIN graph_nodes f ON f.id = e.target_node_id
+                       WHERE e.project = 'project'
+                         AND e.edge_type = 'read'
+                         AND s.node_type = 'session'
+                         AND s.node_name = 'session-graph-test'
+                         AND f.node_type = 'file'
+                         AND f.node_name = 'a.sh';")
+modified_edges=$(eagle_db "SELECT COUNT(*)
+                           FROM graph_edges e
+                           JOIN graph_nodes s ON s.id = e.source_node_id
+                           JOIN graph_nodes f ON f.id = e.target_node_id
+                           WHERE e.project = 'project'
+                             AND e.edge_type = 'modified'
+                             AND s.node_type = 'session'
+                             AND s.node_name = 'session-graph-test'
+                             AND f.node_type = 'file'
+                             AND f.node_name = 'b.sh';")
+if [ "$read_edges" != "1" ] || [ "$modified_edges" != "1" ]; then
+    echo "batched session graph wiring did not normalize absolute paths" >&2
+    exit 1
+fi
+
+rm "$repo/old.sh"
+git -C "$repo" add -u old.sh
+(cd "$repo" && "$EAGLE_BIN" graph rebuild >/dev/null)
+
+stale_count=$(eagle_db "SELECT COUNT(*)
+                        FROM graph_nodes
+                        WHERE project = 'project'
+                          AND (node_name LIKE '%CloudDictationPipeline%'
+                               OR node_name = 'old.sh');")
+if [ "$stale_count" != "0" ]; then
+    echo "graph rebuild left stale removed-file nodes" >&2
+    exit 1
+fi
+
+echo "graph memory regressions passed"