eagle-mem 4.10.4 → 4.10.6

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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:
+
+- **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) |
@@ -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/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/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/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/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.4",
+  "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": [