eagle-mem 1.6.3 → 2.0.0

package/README.md

@@ -5,7 +5,7 @@
 
 # Eagle Mem
 
-Lightweight persistent memory for [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Inspired by [claude-mem](https://github.com/thedotmack/claude-mem) but without the resource-heavy Chroma DB + Bun daemon architecture that consumed 300-600MB per instance.
+Persistent memory for [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Every session starts with context from previous sessions — summaries, memories, tasks, and project overviews — injected automatically via hooks.
 
 **Zero per-instance overhead.** No daemon, no vector DB, no MCP server. Just bash scripts, sqlite3, and jq.
 
@@ -16,33 +16,7 @@ npm install -g eagle-mem
 eagle-mem install
 ```
 
-The installer checks prerequisites and offers to install missing ones:
-
-```
-  █▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
-  ██▄ █▀█ █▄█ █▄▄ ██▄   █ ▀ █ ██▄ █ ▀ █
-
-  Eagle Mem  Install
-  ─────────────────────────────────────
-
-  Checking prerequisites...
-
-  ✓  sqlite3 (3.39.5)
-  ✓  FTS5 support
-  ✓  jq (1.7.1)
-  ✓  Claude Code (~/.claude/)
-
-  Installing Eagle Mem...
-
-  ✓  Files copied to ~/.eagle-mem
-  ✓  Database ready
-  ✓  Hooks registered
-  ✓  Skills installed
-
-  Eagle Mem installed successfully.
-```
-
-Start a new Claude Code session — Eagle Mem activates automatically and shows:
+Start a new Claude Code session — Eagle Mem activates automatically:
 
 ```
 █▀▀ ▄▀█ █▀▀ █   █▀▀   █▀▄▀█ █▀▀ █▀▄▀█
@@ -53,154 +27,71 @@ Sessions: 5 recent | Memories: 3 | Tasks: 2 pending
 Last: Added auth middleware with JWT validation
 ```
 
-## Commands
-
-| Command | What it does |
-|---------|-------------|
-| `eagle-mem install` | First-time setup: checks prerequisites, deploys hooks, creates database, installs skills |
-| `eagle-mem update` | Re-deploys hooks/lib files, runs pending migrations, backfills project names |
-| `eagle-mem scan .` | Analyze a project and generate an overview (auto-injected at session start) |
-| `eagle-mem index .` | Index source files into FTS5-searchable chunks (incremental via mtime) |
-| `eagle-mem search <query>` | Full-text search across summaries, observations, and code chunks |
-| `eagle-mem tasks` | View mirrored Claude Code tasks (read-only — Claude Code manages task state) |
-| `eagle-mem overview` | View or regenerate project overviews |
-| `eagle-mem memories` | List, search, and sync Claude Code auto-memories, plans, and tasks |
-| `eagle-mem memories sync` | Backfill all Claude Code memories, plans, and tasks into Eagle Mem |
-| `eagle-mem prune` | Clean up orphan code chunks and stale data |
-| `eagle-mem uninstall` | Removes hooks from settings.json and optionally deletes data |
-| `eagle-mem help` | Shows usage, commands, and available skills |
-| `eagle-mem version` | Shows current version |
-
-## Why
+## What It Does
 
-Claude Code sessions lose context on `/compact` and between sessions. Eagle Mem solves this with:
+Eagle Mem hooks into Claude Code's lifecycle to solve the context loss problem:
 
-- **Automatic session summaries** saved to a shared SQLite database
-- **Claude Code memory mirror** — mirrors Claude's auto-memories, plans, and tasks into Eagle Mem's SQLite + FTS5
-- **Session-start injection** — project overview, recent summaries, memories, plans, and in-progress tasks surfaced automatically
-- **Compact-safe reload** — full context re-injects after compaction with trigger awareness
-- **TaskAware Compact Loop** using Claude Code's native `TaskCreate`/`TaskUpdate` with dependency support
-- **FTS5 full-text search** across all sessions and projects
-- **Contextual memory injection** — relevant past sessions surfaced when you ask related questions
-- **Privacy controls** — `<private>` tags strip sensitive content before storage
-- **Observation deduplication** — prevents DB bloat from repeated tool calls
-- **Project overviews** — persistent one-paragraph project summaries injected at session start
-- **Concurrent-safe** WAL mode with busy timeout — runs fine across 4-5 simultaneous sessions
-- **Codebase scanning** — auto-generates project overviews from structure analysis
-- **Code indexing** — FTS5-searchable source chunks with incremental re-indexing
-- **Stale data filtering** — noisy auto-captured summaries and 7-day-old tasks are excluded from injection
+- **Session summaries** — automatically captured when Claude's turn ends, stored in SQLite with FTS5 search
+- **Memory mirror** — mirrors Claude Code's auto-memories, plans, and tasks into a searchable database
+- **Context injection** — at session start, injects project overview + recent summaries + relevant memories + in-progress tasks
+- **Compact survival** — after `/compact`, Eagle Mem re-injects full context so Claude picks up where it left off
+- **Privacy** — wrap sensitive content in `<private>` tags and it's stripped before storage
 
-## How It Works
-
-### Hook Lifecycle
+## Hook Lifecycle
 
 | Hook | Fires When | What It Does |
 |------|-----------|--------------|
-| **SessionStart** | startup, resume, clear, compact | Queries DB for project overview, recent summaries, memories, plans, and in-progress tasks. Injects context via stdout. Shows trigger type (startup/compact/clear/resume). |
-| **UserPromptSubmit** | user sends a message | Searches FTS5 for memories relevant to the user's prompt. Injects matching context with ASCII eagle branding. |
-| **Stop** | Claude's turn ends | Parses `<eagle-summary>` from transcript (strips `<private>` tags first). Heuristic fallback extracts user prompt + file paths. Saves summary to DB. |
-| **PostToolUse** | after Read/Write/Edit/Bash/TaskCreate/TaskUpdate | Captures lightweight observations with deduplication (5-second window). Mirrors Claude Code auto-memory, plan, and task writes. |
-| **SessionEnd** | session closes | Re-syncs all task files from `~/.claude/tasks/` to catch status changes, then marks session as completed. |
-
-### Claude Code Memory Mirror
-
-Eagle Mem intercepts Claude Code's built-in memory, plan, and task writes via the PostToolUse hook:
-
-- **Memories** — when Claude writes to `~/.claude/projects/*/memory/*.md`, Eagle Mem mirrors the content with FTS5 indexing
-- **Plans** — when Claude writes to `~/.claude/plans/*.md`, Eagle Mem captures the plan
-- **Tasks** — when Claude calls `TaskCreate` or `TaskUpdate`, Eagle Mem captures the task JSON
-
-These are injected at session start (top 5 memories, top 3 plans, in-progress tasks) and can be searched via CLI:
-
-```bash
-eagle-mem memories               # list all mirrored memories
-eagle-mem memories search "auth" # full-text search
-eagle-mem memories plans         # list captured plans
-eagle-mem memories tasks         # list captured tasks
-eagle-mem memories sync          # backfill everything from Claude Code
-```
-
-**Task resync:** At session end, Eagle Mem re-reads all task JSON files to catch status changes that bypassed the PostToolUse hook (Claude Code can update tasks internally without tool calls).
-
-### Summary Extraction
-
-Eagle Mem injects instructions for Claude to emit an `<eagle-summary>` block before its final response:
-
-```
-<eagle-summary>
-request: What the user asked for
-investigated: Key files/areas explored
-learned: Non-obvious discoveries
-completed: What was accomplished
-next_steps: What should happen next
-files_read: [list of files read]
-files_modified: [list of files modified]
-</eagle-summary>
-```
+| **SessionStart** | startup, resume, clear, compact | Injects project overview, recent summaries, memories, and in-progress tasks |
+| **UserPromptSubmit** | user sends a message | Searches FTS5 for memories relevant to the prompt |
+| **Stop** | Claude's turn ends | Parses `<eagle-summary>` from transcript, saves to DB |
+| **PostToolUse** | after tool calls | Captures observations, mirrors memory/plan/task writes |
+| **SessionEnd** | session closes | Re-syncs tasks, marks session completed |
 
-The Stop hook parses this from the transcript. If Claude doesn't emit one, a heuristic fallback captures the first user prompt and files touched via tool calls.
-
-### Privacy
-
-Wrap sensitive content in `<private>` tags and it will be stripped before storage:
-
-```
-<private>
-API_KEY=sk-secret-123
-DB_PASSWORD=hunter2
-</private>
-```
-
-The Stop hook removes `<private>` blocks at the edge — before any data reaches the database.
+## Commands
 
-### TaskAware Compact Loop
+| Command | What it does |
+|---------|-------------|
+| `eagle-mem refresh` | Full project sync: overview + scan + index + memories + tasks |
+| `eagle-mem search <query>` | FTS5 search across summaries, memories, and code chunks |
+| `eagle-mem search --timeline` | Recent sessions in chronological order |
+| `eagle-mem overview` | View or set the project overview |
+| `eagle-mem scan` | Analyze codebase structure (languages, frameworks, entry points) |
+| `eagle-mem index` | Index source files into FTS5-searchable chunks |
+| `eagle-mem memories` | View/sync mirrored Claude Code memories, plans, and tasks |
+| `eagle-mem tasks` | View mirrored Claude Code tasks |
+| `eagle-mem prune` | Remove old observations and orphaned chunks |
+| `eagle-mem install` | First-time setup: hooks, database, skills |
+| `eagle-mem update` | Re-deploy hooks and run pending migrations |
+| `eagle-mem uninstall` | Remove hooks and optionally delete data |
 
-For complex multi-step work, using Claude Code's native task system:
+## Skills
 
-1. **Plan** — Break the work into tasks via `TaskCreate` with `addBlockedBy` for dependencies
-2. **Execute** — Work on one task at a time (`TaskUpdate` to `in_progress`)
-3. **Complete** — Mark done via `TaskUpdate` to `completed`
-4. **Compact** — Run `/compact` when context fills up
-5. **Resume** — SessionStart re-injects memory + mirrored task state from Eagle Mem
+Seven skills available inside Claude Code sessions:
 
-Claude Code drives all task state. Eagle Mem mirrors it for cross-session recall.
+| Skill | What it does |
+|-------|-------------|
+| `/eagle-mem-search` | Progressive memory recall — search, expand, drill into sessions |
+| `/eagle-mem-overview` | Build a structured project briefing from code, README, and git history |
+| `/eagle-mem-scan` | Analyze codebase structure — languages, frameworks, entry points |
+| `/eagle-mem-index` | Index source files for FTS5 code search across sessions |
+| `/eagle-mem-memories` | View, search, and sync Claude Code's mirrored memories and plans |
+| `/eagle-mem-tasks` | TaskAware Compact Loop — break work into tasks that survive compaction |
+| `/eagle-mem-prune` | Database hygiene — graduated cleanup of stale data |
 
 ## Database
 
-Single shared SQLite database at `~/.eagle-mem/memory.db` with a `project` column on every table for filtering.
-
-### Tables
-
-- **sessions** — Track active/completed sessions per project
-- **observations** — Per-tool-use records with deduplication (files read/modified)
-- **summaries** — Per-session summaries with FTS5 search (UNIQUE on session_id, merge UPSERT)
-- **overviews** — One rolling overview per project (injected at session start)
-- **code_chunks** — FTS5-indexed source file chunks for code-level search
-- **claude_memories** — Mirror of Claude Code auto-memories with FTS5 search
-- **claude_plans** — Mirror of Claude Code plan files with FTS5 search
-- **claude_tasks** — Mirror of Claude Code tasks with FTS5 search (statuses: pending/in_progress/completed/deleted)
-
-### Key Design Choices
-
-- **WAL mode** for concurrent readers across sessions
-- **busy_timeout=5000** to retry on write contention instead of failing
-- **FTS5 content-sync** with auto-triggers to keep search indexes in sync
-- **trusted_schema=ON** required for FTS5 virtual tables
-- **Project identification** via `git rev-parse --show-toplevel` (handles monorepo subdirectories correctly)
-- **Backfill system** resolves project names from Claude Code transcript files at `~/.claude/projects/`
-- PRAGMAs set on every connection (they're connection-scoped, not persistent)
+Single shared SQLite database at `~/.eagle-mem/memory.db`. WAL mode for concurrent sessions, FTS5 for full-text search.
 
-## Skills
-
-Eagle Mem ships with seven skills for use inside Claude Code sessions:
-
-- **eagle-mem-search** — 3-layer search: compact FTS5 search, timeline view, full observations
-- **eagle-mem-tasks** — TaskAware Compact Loop using Claude Code's native TaskCreate/TaskUpdate with dependencies
-- **eagle-mem-overview** — Generate and update a persistent project overview
-- **eagle-mem-index** — Index source files for FTS5 code-level search
-- **eagle-mem-scan** — Scan and analyze a project to generate an overview
-- **eagle-mem-memories** — Browse and search Claude Code memories, plans, and tasks
-- **eagle-mem-prune** — Clean up old observations and orphaned chunks
+| Table | Purpose |
+|-------|---------|
+| sessions | Active/completed sessions per project |
+| summaries | Per-session summaries with FTS5 (UPSERT on session_id) |
+| observations | Per-tool-use records with deduplication |
+| overviews | One rolling overview per project (scan vs manual source tracking) |
+| code_chunks | FTS5-indexed source file chunks |
+| claude_memories | Mirror of Claude Code auto-memories |
+| claude_plans | Mirror of Claude Code plans |
+| claude_tasks | Mirror of Claude Code tasks |
 
 ## Architecture
 
@@ -208,36 +99,27 @@ Eagle Mem ships with seven skills for use inside Claude Code sessions:
 Package (npm)                   Runtime (~/.eagle-mem/)
 ├── bin/eagle-mem   CLI         ├── memory.db         SQLite + FTS5
 ├── scripts/                    ├── eagle-mem.log     Debug log
-│   ├── style.sh                ├── hooks/
-│   ├── install.sh              │   ├── session-start.sh
+│   ├── install.sh              ├── hooks/
+│   ├── update.sh               │   ├── session-start.sh
 │   ├── uninstall.sh            │   ├── user-prompt-submit.sh
-│   ├── update.sh               │   ├── stop.sh
-│   ├── scan.sh                 │   ├── post-tool-use.sh
-│   ├── index.sh                │   └── session-end.sh
-│   ├── search.sh               ├── lib/
-│   ├── tasks.sh                │   ├── common.sh
-│   ├── overview.sh             │   ├── db.sh
-│   ├── memories.sh             │   └── hooks.sh
-│   │                           └── db/
-│   ├── prune.sh                    ├── migrate.sh
-│   ├── statusline-em.sh            ├── schema.sql
-│   └── help.sh                    ├── 002_overviews.sql
-├── hooks/          Source          ├── 003_code_chunks.sql
-├── lib/            Source          ├── 004_observation_indexes.sql
-│   ├── common.sh                  ├── 005_claude_memories.sql
-│   ├── db.sh                      ├── 006_claude_plans.sql
-│   └── hooks.sh                   ├── 007_claude_tasks.sql
-├── db/             Source          ├── 008_summary_upsert.sql
-│   ├── migrate.sh                 └── 009_drop_dead_tasks.sql
-│   ├── schema.sql
-│   └── [0-9]*.sql  Migrations
-└── skills/         Symlinked → ~/.claude/skills/
+│   ├── search.sh               │   ├── stop.sh
+│   ├── overview.sh             │   ├── post-tool-use.sh
+│   ├── tasks.sh                │   └── session-end.sh
+│   ├── prune.sh                ├── lib/
+│   ├── scan.sh                 │   ├── common.sh
+│   ├── index.sh                │   ├── db.sh
+│   ├── refresh.sh              │   └── hooks.sh
+│   └── help.sh                 └── db/
+├── hooks/          Source          ├── schema.sql
+├── lib/            Source          └── [0-9]*.sql  Migrations
+├── db/             Source
+└── skills/         → ~/.claude/skills/
     ├── eagle-mem-search/
-    ├── eagle-mem-tasks/
     ├── eagle-mem-overview/
-    ├── eagle-mem-index/
     ├── eagle-mem-scan/
+    ├── eagle-mem-index/
     ├── eagle-mem-memories/
+    ├── eagle-mem-tasks/
     └── eagle-mem-prune/
 ```
 
@@ -245,13 +127,6 @@ Package (npm)                   Runtime (~/.eagle-mem/)
 
 ```bash
 eagle-mem uninstall
-```
-
-Removes hooks from `~/.claude/settings.json` and skill symlinks. Optionally deletes `~/.eagle-mem/` (prompts for confirmation).
-
-To also remove the npm package:
-
-```bash
 npm uninstall -g eagle-mem
 ```
 
@@ -261,14 +136,6 @@ npm uninstall -g eagle-mem
 - `jq` (the installer offers to install if missing)
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed (`~/.claude/` must exist)
 
-## Roadmap
-
-- [ ] **v2**: sqlite-vec embeddings for semantic code search
-- [ ] Timeline report skill (narrative project history from pure SQL)
-- [x] ~~Claude Code memory/plan/task mirror~~
-- [x] ~~ASCII eagle branding across hooks and CLI~~
-- [x] ~~Compact-safe context reload~~
-
 ## License
 
 MIT

package/bin/eagle-mem

@@ -24,6 +24,7 @@ case "$command" in
     search)     bash "$SCRIPTS_DIR/search.sh" "$@" ;;
     tasks)      bash "$SCRIPTS_DIR/tasks.sh" "$@" ;;
     overview)   bash "$SCRIPTS_DIR/overview.sh" "$@" ;;
+    refresh)    bash "$SCRIPTS_DIR/refresh.sh" "$@" ;;
     prune)      bash "$SCRIPTS_DIR/prune.sh" "$@" ;;
     memories)   bash "$SCRIPTS_DIR/memories.sh" "$@" ;;
     help|--help|-h)

package/db/010_session_activity.sql

@@ -0,0 +1,15 @@
+-- ═══════════════════════════════════════════════════════════
+-- Eagle Mem — Migration 010: Session activity tracking
+-- Adds last_activity_at for accurate stuck-session sweeping
+-- ═══════════════════════════════════════════════════════════
+
+PRAGMA foreign_keys = ON;
+
+ALTER TABLE sessions ADD COLUMN last_activity_at TEXT;
+
+UPDATE sessions SET last_activity_at = COALESCE(ended_at, started_at);
+
+CREATE TRIGGER IF NOT EXISTS observations_touch_session AFTER INSERT ON observations
+BEGIN
+    UPDATE sessions SET last_activity_at = NEW.created_at WHERE id = NEW.session_id;
+END;

package/db/011_overview_source.sql

@@ -0,0 +1,10 @@
+-- ═══════════════════════════════════════════════════════════
+-- Eagle Mem — Migration 011: Overview source tracking
+-- Tracks whether overview was written by scan or manually
+-- ═══════════════════════════════════════════════════════════
+
+PRAGMA foreign_keys = ON;
+
+ALTER TABLE overviews ADD COLUMN source TEXT NOT NULL DEFAULT 'manual';
+
+UPDATE overviews SET source = 'scan' WHERE length(content) <= 300;

package/hooks/post-tool-use.sh

@@ -124,12 +124,6 @@ case "$tool_name" in
         ;;
 esac
 
-# Deduplicate: skip if exact same observation within last 5 seconds
-dup_count=$(eagle_observation_exists "$session_id" "$tool_name" "$tool_summary")
-if [ "$dup_count" != "0" ]; then
-    exit 0
-fi
-
 eagle_insert_observation "$session_id" "$project" "$tool_name" "$tool_summary" "$files_read" "$files_modified"
 
 exit 0

package/hooks/session-start.sh

@@ -30,12 +30,13 @@ eagle_log "INFO" "SessionStart: session=$session_id project=$project source=$sou
 
 eagle_upsert_session "$session_id" "$project" "$cwd" "$model" "$source_type"
 
-# ─── Sweep stuck sessions (older than 4 hours) ─────────────
-# Exclude the current session — it may be a resumed session older than 4h
+# ─── Sweep stuck sessions (no activity for 7 days) ─────────
+# Uses last_activity_at (updated by trigger on every observation insert)
+# so long-lived sessions with regular compactions aren't falsely abandoned
 eagle_db "UPDATE sessions SET status = 'abandoned'
     WHERE status = 'active'
     AND id != '$(eagle_sql_escape "$session_id")'
-    AND started_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-4 hours');"
+    AND COALESCE(last_activity_at, started_at) < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-7 days');"
 
 # ─── Build context injection ────────────────────────────────
 
@@ -49,12 +50,17 @@ Eagle Mem (https://github.com/eagleisbatman/eagle-mem) is providing persistent m
 
 "
 
-# Project overview (if one exists)
+# Project overview
 overview=$(eagle_get_overview "$project")
 if [ -n "$overview" ]; then
     context+="=== EAGLE MEM — Project Overview ===
 $overview
 
+"
+else
+    context+="=== EAGLE MEM — Action Required ===
+No overview exists for '$project'. On the user's first prompt, run /eagle-mem-overview to build a structured project briefing. The skill has full instructions for what to read and how to write a rich overview.
+
 "
 fi
 
@@ -129,11 +135,11 @@ Tasks for '$project':
 "
     while IFS='|' read -r tsubject tstatus tblocked; do
         [ -z "$tsubject" ] && continue
-        local_marker=""
+        block_marker=""
         if [ "$tblocked" != "[]" ] && [ -n "$tblocked" ]; then
-            local_marker=" (blocked)"
+            block_marker=" (blocked)"
         fi
-        context+="  - [$tstatus] $tsubject$local_marker
+        context+="  - [$tstatus] $tsubject$block_marker
 "
     done <<< "$synced_tasks"
 fi

package/lib/db.sh

@@ -40,13 +40,14 @@ eagle_upsert_session() {
     local model; model=$(eagle_sql_escape "${4:-}")
     local source; source=$(eagle_sql_escape "${5:-}")
 
-    eagle_db "INSERT INTO sessions (id, project, cwd, model, source)
-              VALUES ('$session_id', '$project', '$cwd', '$model', '$source')
+    eagle_db "INSERT INTO sessions (id, project, cwd, model, source, last_activity_at)
+              VALUES ('$session_id', '$project', '$cwd', '$model', '$source', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
               ON CONFLICT(id) DO UPDATE SET
                   cwd = COALESCE(excluded.cwd, sessions.cwd),
                   model = COALESCE(excluded.model, sessions.model),
                   source = COALESCE(excluded.source, sessions.source),
-                  status = 'active';"
+                  status = 'active',
+                  last_activity_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now');"
 }
 
 eagle_end_session() {
@@ -63,7 +64,14 @@ eagle_insert_observation() {
     local files_modified; files_modified=$(eagle_sql_escape "$6")
 
     eagle_db "INSERT INTO observations (session_id, project, tool_name, tool_input_summary, files_read, files_modified)
-              VALUES ('$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'
+              WHERE NOT EXISTS (
+                  SELECT 1 FROM observations
+                  WHERE session_id = '$session_id'
+                  AND tool_name = '$tool_name'
+                  AND tool_input_summary = '$tool_input_summary'
+                  AND created_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-5 seconds')
+              );"
 }
 
 eagle_insert_summary() {
@@ -138,29 +146,31 @@ eagle_search_summaries() {
               LIMIT $limit;"
 }
 
-eagle_observation_exists() {
-    local session_id; session_id=$(eagle_sql_escape "$1")
-    local tool_name; tool_name=$(eagle_sql_escape "$2")
-    local tool_summary; tool_summary=$(eagle_sql_escape "$3")
-
-    eagle_db "SELECT COUNT(*) FROM observations
-              WHERE session_id = '$session_id'
-              AND tool_name = '$tool_name'
-              AND tool_input_summary = '$tool_summary'
-              AND created_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-5 seconds');"
-}
-
 eagle_upsert_overview() {
     local project; project=$(eagle_sql_escape "$1")
-    local content; content=$(eagle_sql_escape "$2")
+    local raw_content="$2"
+    local ov_source; ov_source=$(eagle_sql_escape "${3:-manual}")
+
+    if [ ${#raw_content} -gt 16384 ]; then
+        raw_content="${raw_content:0:16384}"
+        eagle_log "WARN" "Overview for '$1' truncated to 16 KB (was ${#2} bytes)"
+    fi
 
-    eagle_db "INSERT INTO overviews (project, content, updated_at)
-              VALUES ('$project', '$content', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    local content; content=$(eagle_sql_escape "$raw_content")
+
+    eagle_db "INSERT INTO overviews (project, content, source, updated_at)
+              VALUES ('$project', '$content', '$ov_source', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
               ON CONFLICT(project) DO UPDATE SET
                   content = excluded.content,
+                  source = excluded.source,
                   updated_at = excluded.updated_at;"
 }
 
+eagle_get_overview_source() {
+    local project; project=$(eagle_sql_escape "$1")
+    eagle_db "SELECT source FROM overviews WHERE project = '$project';"
+}
+
 eagle_get_overview() {
     local project; project=$(eagle_sql_escape "$1")
 
@@ -495,24 +505,24 @@ eagle_backfill_projects() {
         sid_sql=$(eagle_sql_escape "$sid")
         proj_sql=$(eagle_sql_escape "$project")
 
+        # All six tables updated atomically per session to prevent
+        # partial backfill if the process is interrupted.
+        # Note: total_changes() includes FTS trigger changes, so the
+        # reported count may be higher than actual rows updated.
+        # This is cosmetic — the count is only used for status messages.
         local ch
-        ch=$(eagle_db "UPDATE sessions SET project = '$proj_sql' WHERE id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
-SELECT changes();")
-        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
-        ch=$(eagle_db "UPDATE claude_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
-SELECT changes();")
-        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
-        ch=$(eagle_db "UPDATE claude_memories SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
-SELECT changes();")
-        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
-        ch=$(eagle_db "UPDATE claude_plans SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
-SELECT changes();")
-        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
-        ch=$(eagle_db "UPDATE summaries SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
-SELECT changes();")
-        [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
-        ch=$(eagle_db "UPDATE observations SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
-SELECT changes();")
+        ch=$(eagle_db_pipe <<SQL
+BEGIN;
+UPDATE sessions SET project = '$proj_sql' WHERE id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE claude_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE claude_memories SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE claude_plans SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE summaries SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE observations SET project = '$proj_sql' WHERE session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT total_changes();
+COMMIT;
+SQL
+)
         [ "${ch:-0}" -gt 0 ] && updated=$((updated + ch))
     done <<< "$map"
 
@@ -528,13 +538,21 @@ eagle_prune_orphan_chunks() {
     paths=$(eagle_db "SELECT DISTINCT file_path FROM code_chunks WHERE project = '$project';")
 
     local removed=0
+    local txn_sql="BEGIN;"
     while IFS= read -r fpath; do
         [ -z "$fpath" ] && continue
         if [ ! -f "$target_dir/$fpath" ]; then
             local fpath_sql; fpath_sql=$(eagle_sql_escape "$fpath")
-            eagle_db "DELETE FROM code_chunks WHERE project = '$project' AND file_path = '$fpath_sql';"
+            txn_sql+="
+DELETE FROM code_chunks WHERE project = '$project' AND file_path = '$fpath_sql';"
             removed=$((removed + 1))
         fi
     done <<< "$paths"
+    txn_sql+="
+COMMIT;"
+
+    if [ "$removed" -gt 0 ]; then
+        eagle_db_pipe <<< "$txn_sql"
+    fi
     echo "$removed"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eagle-mem",
-  "version": "1.6.3",
-  "description": "Lightweight persistent memory for Claude Code — SQLite + FTS5, no daemon, no bloat",
+  "version": "2.0.0",
+  "description": "Persistent memory for Claude Code — SQLite + FTS5, no daemon, no bloat",
   "bin": {
     "eagle-mem": "bin/eagle-mem"
   },