eagle-mem 1.2.0 → 1.3.1

package/bin/eagle-mem

@@ -25,6 +25,7 @@ case "$command" in
     tasks)      bash "$SCRIPTS_DIR/tasks.sh" "$@" ;;
     overview)   bash "$SCRIPTS_DIR/overview.sh" "$@" ;;
     prune)      bash "$SCRIPTS_DIR/prune.sh" "$@" ;;
+    memories)   bash "$SCRIPTS_DIR/memories.sh" "$@" ;;
     help|--help|-h)
                 bash "$SCRIPTS_DIR/help.sh" ;;
     version|--version|-v|-V)

package/db/005_claude_memories.sql

@@ -0,0 +1,49 @@
+-- ═══════════════════════════════════════════════════════════
+-- Eagle Mem — Migration 005: Claude Code memory mirror
+-- Captures Claude Code auto-memory writes into Eagle Mem
+-- ═══════════════════════════════════════════════════════════
+
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS claude_memories (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    project         TEXT NOT NULL,
+    file_path       TEXT NOT NULL UNIQUE,
+    memory_name     TEXT,
+    description     TEXT,
+    memory_type     TEXT,
+    content         TEXT,
+    content_hash    TEXT,
+    origin_session_id TEXT,
+    captured_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_claude_memories_project ON claude_memories(project);
+CREATE INDEX IF NOT EXISTS idx_claude_memories_type ON claude_memories(memory_type);
+
+-- FTS5 for searching across memory content
+CREATE VIRTUAL TABLE IF NOT EXISTS claude_memories_fts USING fts5(
+    memory_name,
+    description,
+    content,
+    content='claude_memories',
+    content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS claude_memories_ai AFTER INSERT ON claude_memories BEGIN
+    INSERT INTO claude_memories_fts(rowid, memory_name, description, content)
+    VALUES (new.id, new.memory_name, new.description, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS claude_memories_ad AFTER DELETE ON claude_memories BEGIN
+    INSERT INTO claude_memories_fts(claude_memories_fts, rowid, memory_name, description, content)
+    VALUES ('delete', old.id, old.memory_name, old.description, old.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS claude_memories_au AFTER UPDATE ON claude_memories BEGIN
+    INSERT INTO claude_memories_fts(claude_memories_fts, rowid, memory_name, description, content)
+    VALUES ('delete', old.id, old.memory_name, old.description, old.content);
+    INSERT INTO claude_memories_fts(rowid, memory_name, description, content)
+    VALUES (new.id, new.memory_name, new.description, new.content);
+END;

package/db/006_claude_plans.sql

@@ -0,0 +1,45 @@
+-- ═══════════════════════════════════════════════════════════
+-- Eagle Mem — Migration 006: Claude Code plan mirror
+-- Captures Claude Code plan documents into Eagle Mem
+-- ═══════════════════════════════════════════════════════════
+
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS claude_plans (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    project         TEXT NOT NULL DEFAULT '',
+    file_path       TEXT NOT NULL UNIQUE,
+    title           TEXT,
+    content         TEXT,
+    content_hash    TEXT,
+    origin_session_id TEXT,
+    captured_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_claude_plans_project ON claude_plans(project);
+
+-- FTS5 for searching across plan content
+CREATE VIRTUAL TABLE IF NOT EXISTS claude_plans_fts USING fts5(
+    title,
+    content,
+    content='claude_plans',
+    content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS claude_plans_ai AFTER INSERT ON claude_plans BEGIN
+    INSERT INTO claude_plans_fts(rowid, title, content)
+    VALUES (new.id, new.title, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS claude_plans_ad AFTER DELETE ON claude_plans BEGIN
+    INSERT INTO claude_plans_fts(claude_plans_fts, rowid, title, content)
+    VALUES ('delete', old.id, old.title, old.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS claude_plans_au AFTER UPDATE ON claude_plans BEGIN
+    INSERT INTO claude_plans_fts(claude_plans_fts, rowid, title, content)
+    VALUES ('delete', old.id, old.title, old.content);
+    INSERT INTO claude_plans_fts(rowid, title, content)
+    VALUES (new.id, new.title, new.content);
+END;

package/db/007_claude_tasks.sql

@@ -0,0 +1,50 @@
+-- ═══════════════════════════════════════════════════════════
+-- Migration 007: Claude Code task mirror
+-- Mirrors TaskCreate/TaskUpdate artifacts from ~/.claude/tasks/
+-- ═══════════════════════════════════════════════════════════
+
+CREATE TABLE IF NOT EXISTS claude_tasks (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    project           TEXT NOT NULL DEFAULT '',
+    source_session_id TEXT NOT NULL,
+    source_task_id    TEXT NOT NULL,
+    file_path         TEXT UNIQUE,
+    subject           TEXT,
+    description       TEXT,
+    active_form       TEXT,
+    status            TEXT NOT NULL DEFAULT 'pending',
+    blocks            TEXT DEFAULT '[]',
+    blocked_by        TEXT DEFAULT '[]',
+    content_hash      TEXT,
+    captured_at       TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at        TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_claude_tasks_project ON claude_tasks(project);
+CREATE INDEX IF NOT EXISTS idx_claude_tasks_session ON claude_tasks(source_session_id);
+CREATE INDEX IF NOT EXISTS idx_claude_tasks_status ON claude_tasks(status);
+
+-- FTS5 for full-text search on subject + description
+CREATE VIRTUAL TABLE IF NOT EXISTS claude_tasks_fts USING fts5(
+    subject,
+    description,
+    content='claude_tasks',
+    content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS claude_tasks_ai AFTER INSERT ON claude_tasks BEGIN
+    INSERT INTO claude_tasks_fts(rowid, subject, description)
+    VALUES (new.id, new.subject, new.description);
+END;
+
+CREATE TRIGGER IF NOT EXISTS claude_tasks_ad AFTER DELETE ON claude_tasks BEGIN
+    INSERT INTO claude_tasks_fts(claude_tasks_fts, rowid, subject, description)
+    VALUES ('delete', old.id, old.subject, old.description);
+END;
+
+CREATE TRIGGER IF NOT EXISTS claude_tasks_au AFTER UPDATE ON claude_tasks BEGIN
+    INSERT INTO claude_tasks_fts(claude_tasks_fts, rowid, subject, description)
+    VALUES ('delete', old.id, old.subject, old.description);
+    INSERT INTO claude_tasks_fts(rowid, subject, description)
+    VALUES (new.id, new.subject, new.description);
+END;

package/db/migrate.sh

@@ -47,4 +47,13 @@ run_migration "003_code_chunks" "$SCRIPT_DIR/003_code_chunks.sql"
 # ─── Migration 004: Observation indexes ──────────────────
 run_migration "004_observation_indexes" "$SCRIPT_DIR/004_observation_indexes.sql"
 
+# ─── Migration 005: Claude Code memory mirror ────────────
+run_migration "005_claude_memories" "$SCRIPT_DIR/005_claude_memories.sql"
+
+# ─── Migration 006: Claude Code plan mirror ──────────────
+run_migration "006_claude_plans" "$SCRIPT_DIR/006_claude_plans.sql"
+
+# ─── Migration 007: Claude Code task mirror ──────────────
+run_migration "007_claude_tasks" "$SCRIPT_DIR/007_claude_tasks.sql"
+
 echo "  Eagle Mem database ready: $DB"

package/hooks/post-tool-use.sh

@@ -21,9 +21,9 @@ tool_name=$(echo "$input" | jq -r '.tool_name // empty')
 
 if [ -z "$session_id" ] || [ -z "$tool_name" ]; then exit 0; fi
 
-# Only track file-related tools
+# Only track relevant tools
 case "$tool_name" in
-    Read|Write|Edit|Bash) ;;
+    Read|Write|Edit|Bash|TaskCreate|TaskUpdate) ;;
     *) exit 0 ;;
 esac
 
@@ -63,6 +63,50 @@ case "$tool_name" in
             -e 's/(Authorization: )[^ ]*/\1[REDACTED]/gi')
         tool_summary="Bash: $cmd"
         ;;
+    TaskCreate|TaskUpdate)
+        task_subject=$(echo "$input" | jq -r '.tool_input.subject // empty')
+        tool_summary="$tool_name: $task_subject"
+        ;;
+esac
+
+# ─── Claude memory + plan mirror ─────────────────────────
+# Intercept writes to Claude Code's auto-memory and plan files
+case "$tool_name" in
+    Write|Edit)
+        if [ -n "$fp" ]; then
+            case "$fp" in
+                "$HOME/.claude/projects"/*/memory/*.md)
+                    mem_base=$(basename "$fp")
+                    if [ "$mem_base" != "MEMORY.md" ] && [ -f "$fp" ]; then
+                        eagle_capture_claude_memory "$fp" "$session_id" "$project"
+                    fi
+                    ;;
+                "$HOME/.claude/plans/"*.md)
+                    if [ -f "$fp" ]; then
+                        eagle_capture_claude_plan "$fp" "$session_id" "$project"
+                    fi
+                    ;;
+            esac
+        fi
+        ;;
+esac
+
+# ─── Claude task mirror ─────────────────────────────────
+# Intercept TaskCreate/TaskUpdate and capture the resulting JSON files
+case "$tool_name" in
+    TaskCreate|TaskUpdate)
+        task_dir="$HOME/.claude/tasks/$session_id"
+        if [ -d "$task_dir" ]; then
+            task_id=$(echo "$input" | jq -r '.tool_input.id // empty')
+            if [ -z "$task_id" ]; then
+                newest=$(ls -t "$task_dir"/*.json 2>/dev/null | head -1)
+                [ -n "$newest" ] && [ -f "$newest" ] && eagle_capture_claude_task "$newest" "$session_id" "$project"
+            else
+                task_json="$task_dir/$task_id.json"
+                [ -f "$task_json" ] && eagle_capture_claude_task "$task_json" "$session_id" "$project"
+            fi
+        fi
+        ;;
 esac
 
 # Deduplicate: skip if exact same observation within last 5 seconds

package/lib/common.sh

@@ -18,7 +18,13 @@ eagle_log() {
 
 eagle_project_from_cwd() {
     local cwd="${1:-$(pwd)}"
-    basename "$cwd"
+    local git_root
+    git_root=$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)
+    if [ -n "$git_root" ]; then
+        basename "$git_root"
+    else
+        basename "$cwd"
+    fi
 }
 
 eagle_sql_escape() {

package/lib/db.sh

@@ -240,6 +240,324 @@ eagle_prune_observations() {
     eagle_db "DELETE FROM observations WHERE created_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-$days days') $project_filter;"
 }
 
+eagle_capture_claude_memory() {
+    local file_path="$1"
+    local session_id="${2:-}"
+    local project="${3:-}"
+
+    [ ! -f "$file_path" ] && return 0
+
+    local chash
+    chash=$(shasum -a 256 "$file_path" | awk '{print $1}')
+
+    local fm body
+    fm=$(awk '/^---$/{c++; next} c==1' "$file_path")
+    body=$(awk '/^---$/{c++; next} c>=2' "$file_path")
+
+    _fm_field() { printf '%s\n' "$fm" | awk -F': *' -v k="$1" '$1==k{sub(/^[^:]+: */,""); gsub(/^"|"$/,""); print; exit}'; }
+
+    local mname mdesc mtype morigin
+    mname=$(_fm_field "name")
+    mdesc=$(_fm_field "description")
+    mtype=$(_fm_field "type")
+    morigin=$(_fm_field "originSessionId")
+    [ -z "$morigin" ] && morigin="$session_id"
+
+    local fp_sql proj_sql name_sql desc_sql type_sql content_sql hash_sql origin_sql
+    fp_sql=$(eagle_sql_escape "$file_path")
+    proj_sql=$(eagle_sql_escape "$project")
+    name_sql=$(eagle_sql_escape "$mname")
+    desc_sql=$(eagle_sql_escape "$mdesc")
+    type_sql=$(eagle_sql_escape "$mtype")
+    content_sql=$(eagle_sql_escape "$body")
+    hash_sql=$(eagle_sql_escape "$chash")
+    origin_sql=$(eagle_sql_escape "$morigin")
+
+    eagle_db_pipe <<SQL
+INSERT INTO claude_memories (project, file_path, memory_name, description, memory_type, content, content_hash, origin_session_id)
+VALUES ('$proj_sql', '$fp_sql', '$name_sql', '$desc_sql', '$type_sql', '$content_sql', '$hash_sql', '$origin_sql')
+ON CONFLICT(file_path) DO UPDATE SET
+    memory_name     = excluded.memory_name,
+    description     = excluded.description,
+    memory_type     = excluded.memory_type,
+    content         = excluded.content,
+    content_hash    = excluded.content_hash,
+    origin_session_id = excluded.origin_session_id,
+    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE claude_memories.content_hash != excluded.content_hash;
+SQL
+}
+
+eagle_search_claude_memories() {
+    local query; query=$(eagle_fts_sanitize "$1")
+    query=$(eagle_sql_escape "$query")
+    local project="${2:-}"
+    local limit; limit=$(eagle_sql_int "${3:-10}")
+
+    local where_clause=""
+    if [ -n "$project" ]; then
+        project=$(eagle_sql_escape "$project")
+        where_clause="AND m.project = '$project'"
+    fi
+
+    eagle_db "SELECT m.memory_name, m.memory_type, m.description,
+                     replace(substr(m.content, 1, 200), char(10), ' '),
+                     m.file_path, m.updated_at
+              FROM claude_memories m
+              JOIN claude_memories_fts f ON f.rowid = m.id
+              WHERE claude_memories_fts MATCH '$query'
+              $where_clause
+              ORDER BY rank
+              LIMIT $limit;"
+}
+
+eagle_list_claude_memories() {
+    local project="${1:-}"
+    local limit; limit=$(eagle_sql_int "${2:-20}")
+
+    local where_clause=""
+    if [ -n "$project" ]; then
+        project=$(eagle_sql_escape "$project")
+        where_clause="WHERE project = '$project'"
+    fi
+
+    eagle_db "SELECT memory_name, memory_type, description, file_path, updated_at
+              FROM claude_memories
+              $where_clause
+              ORDER BY updated_at DESC
+              LIMIT $limit;"
+}
+
+eagle_get_claude_memory() {
+    local file_path; file_path=$(eagle_sql_escape "$1")
+    eagle_db "SELECT memory_name, memory_type, description, content, file_path, updated_at, origin_session_id
+              FROM claude_memories
+              WHERE file_path = '$file_path';"
+}
+
+eagle_capture_claude_plan() {
+    local file_path="$1"
+    local session_id="${2:-}"
+    local project="${3:-}"
+
+    [ ! -f "$file_path" ] && return 0
+
+    local chash
+    chash=$(shasum -a 256 "$file_path" | awk '{print $1}')
+
+    local title content
+    title=$(awk '/^# /{print; exit}' "$file_path" | sed 's/^# //')
+    content=$(cat "$file_path")
+
+    local fp_sql proj_sql title_sql content_sql hash_sql origin_sql
+    fp_sql=$(eagle_sql_escape "$file_path")
+    proj_sql=$(eagle_sql_escape "$project")
+    title_sql=$(eagle_sql_escape "$title")
+    content_sql=$(eagle_sql_escape "$content")
+    hash_sql=$(eagle_sql_escape "$chash")
+    origin_sql=$(eagle_sql_escape "$session_id")
+
+    eagle_db_pipe <<SQL
+INSERT INTO claude_plans (project, file_path, title, content, content_hash, origin_session_id)
+VALUES ('$proj_sql', '$fp_sql', '$title_sql', '$content_sql', '$hash_sql', '$origin_sql')
+ON CONFLICT(file_path) DO UPDATE SET
+    title           = excluded.title,
+    content         = excluded.content,
+    content_hash    = excluded.content_hash,
+    origin_session_id = COALESCE(NULLIF(excluded.origin_session_id, ''), claude_plans.origin_session_id),
+    project         = CASE WHEN excluded.project != '' THEN excluded.project ELSE claude_plans.project END,
+    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE claude_plans.content_hash != excluded.content_hash;
+SQL
+}
+
+eagle_search_claude_plans() {
+    local query; query=$(eagle_fts_sanitize "$1")
+    query=$(eagle_sql_escape "$query")
+    local project="${2:-}"
+    local limit; limit=$(eagle_sql_int "${3:-10}")
+
+    local where_clause=""
+    if [ -n "$project" ]; then
+        project=$(eagle_sql_escape "$project")
+        where_clause="AND p.project = '$project'"
+    fi
+
+    eagle_db "SELECT p.title, p.project,
+                     replace(substr(p.content, 1, 200), char(10), ' '),
+                     p.file_path, p.updated_at
+              FROM claude_plans p
+              JOIN claude_plans_fts f ON f.rowid = p.id
+              WHERE claude_plans_fts MATCH '$query'
+              $where_clause
+              ORDER BY rank
+              LIMIT $limit;"
+}
+
+eagle_list_claude_plans() {
+    local project="${1:-}"
+    local limit; limit=$(eagle_sql_int "${2:-20}")
+
+    local where_clause=""
+    if [ -n "$project" ]; then
+        project=$(eagle_sql_escape "$project")
+        where_clause="WHERE project = '$project'"
+    fi
+
+    eagle_db "SELECT title, project, file_path, updated_at
+              FROM claude_plans
+              $where_clause
+              ORDER BY updated_at DESC
+              LIMIT $limit;"
+}
+
+eagle_capture_claude_task() {
+    local file_path="$1"
+    local session_id="${2:-}"
+    local project="${3:-}"
+
+    [ ! -f "$file_path" ] && return 0
+
+    local chash
+    chash=$(shasum -a 256 "$file_path" | awk '{print $1}')
+
+    local task_json
+    task_json=$(cat "$file_path")
+
+    local task_id subject desc active_form status blocks blocked_by
+    task_id=$(printf '%s' "$task_json" | jq -r '.id // empty')
+    subject=$(printf '%s' "$task_json" | jq -r '.subject // empty')
+    desc=$(printf '%s' "$task_json" | jq -r '.description // empty')
+    active_form=$(printf '%s' "$task_json" | jq -r '.activeForm // empty')
+    status=$(printf '%s' "$task_json" | jq -r '.status // "pending"')
+    blocks=$(printf '%s' "$task_json" | jq -c '.blocks // []')
+    blocked_by=$(printf '%s' "$task_json" | jq -c '.blockedBy // []')
+
+    [ -z "$task_id" ] && return 0
+
+    local fp_sql proj_sql sid_sql tid_sql subj_sql desc_sql af_sql status_sql blocks_sql bb_sql hash_sql
+    fp_sql=$(eagle_sql_escape "$file_path")
+    proj_sql=$(eagle_sql_escape "$project")
+    sid_sql=$(eagle_sql_escape "$session_id")
+    tid_sql=$(eagle_sql_escape "$task_id")
+    subj_sql=$(eagle_sql_escape "$subject")
+    desc_sql=$(eagle_sql_escape "$desc")
+    af_sql=$(eagle_sql_escape "$active_form")
+    status_sql=$(eagle_sql_escape "$status")
+    blocks_sql=$(eagle_sql_escape "$blocks")
+    bb_sql=$(eagle_sql_escape "$blocked_by")
+    hash_sql=$(eagle_sql_escape "$chash")
+
+    eagle_db_pipe <<SQL
+INSERT INTO claude_tasks (project, source_session_id, source_task_id, file_path, subject, description, active_form, status, blocks, blocked_by, content_hash)
+VALUES ('$proj_sql', '$sid_sql', '$tid_sql', '$fp_sql', '$subj_sql', '$desc_sql', '$af_sql', '$status_sql', '$blocks_sql', '$bb_sql', '$hash_sql')
+ON CONFLICT(file_path) DO UPDATE SET
+    subject         = excluded.subject,
+    description     = excluded.description,
+    active_form     = excluded.active_form,
+    status          = excluded.status,
+    blocks          = excluded.blocks,
+    blocked_by      = excluded.blocked_by,
+    content_hash    = excluded.content_hash,
+    project         = CASE WHEN excluded.project != '' THEN excluded.project ELSE claude_tasks.project END,
+    updated_at      = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE claude_tasks.content_hash != excluded.content_hash;
+SQL
+}
+
+eagle_list_claude_tasks() {
+    local project="${1:-}"
+    local limit; limit=$(eagle_sql_int "${2:-20}")
+
+    local where_clause=""
+    if [ -n "$project" ]; then
+        project=$(eagle_sql_escape "$project")
+        where_clause="WHERE project = '$project'"
+    fi
+
+    eagle_db "SELECT subject, status, source_session_id, source_task_id, updated_at
+              FROM claude_tasks
+              $where_clause
+              ORDER BY updated_at DESC
+              LIMIT $limit;"
+}
+
+eagle_search_claude_tasks() {
+    local query; query=$(eagle_fts_sanitize "$1")
+    query=$(eagle_sql_escape "$query")
+    local project="${2:-}"
+    local limit; limit=$(eagle_sql_int "${3:-10}")
+
+    local where_clause=""
+    if [ -n "$project" ]; then
+        project=$(eagle_sql_escape "$project")
+        where_clause="AND t.project = '$project'"
+    fi
+
+    eagle_db "SELECT t.subject, t.status,
+                     replace(substr(t.description, 1, 200), char(10), ' '),
+                     t.source_session_id, t.source_task_id, t.updated_at
+              FROM claude_tasks t
+              JOIN claude_tasks_fts f ON f.rowid = t.id
+              WHERE claude_tasks_fts MATCH '$query'
+              $where_clause
+              ORDER BY rank
+              LIMIT $limit;"
+}
+
+eagle_build_session_project_map() {
+    local claude_projects_dir="$HOME/.claude/projects"
+    [ ! -d "$claude_projects_dir" ] && return 0
+
+    for proj_dir in "$claude_projects_dir"/*/; do
+        [ ! -d "$proj_dir" ] && continue
+
+        local project=""
+        local sample_jsonl
+        sample_jsonl=$(ls "$proj_dir"*.jsonl 2>/dev/null | head -1)
+        if [ -n "$sample_jsonl" ] && [ -f "$sample_jsonl" ]; then
+            local cwd
+            cwd=$(head -10 "$sample_jsonl" | jq -r 'select(.cwd != null) | .cwd' 2>/dev/null | head -1)
+            if [ -n "$cwd" ]; then
+                project=$(eagle_project_from_cwd "$cwd")
+            fi
+        fi
+        [ -z "$project" ] && continue
+
+        for jsonl in "$proj_dir"*.jsonl; do
+            [ ! -f "$jsonl" ] && continue
+            local sid
+            sid=$(basename "$jsonl" .jsonl)
+            echo "$sid|$project"
+        done
+    done
+}
+
+eagle_backfill_projects() {
+    local updated=0
+    local map
+    map=$(eagle_build_session_project_map)
+    [ -z "$map" ] && echo "0" && return 0
+
+    while IFS='|' read -r sid project; do
+        [ -z "$sid" ] || [ -z "$project" ] && continue
+        local sid_sql proj_sql
+        sid_sql=$(eagle_sql_escape "$sid")
+        proj_sql=$(eagle_sql_escape "$project")
+
+        local changed
+        changed=$(eagle_db "UPDATE sessions SET project = '$proj_sql' WHERE id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT changes();")
+        changed=$(eagle_db "UPDATE claude_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+SELECT changes();")
+        [ "${changed:-0}" -gt 0 ] && updated=$((updated + changed))
+        eagle_db "UPDATE claude_memories SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');"
+        eagle_db "UPDATE claude_plans SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');"
+    done <<< "$map"
+
+    echo "$updated"
+}
+
 eagle_prune_orphan_chunks() {
     local project; project=$(eagle_sql_escape "$1")
     local target_dir="$2"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Lightweight persistent memory for Claude Code — SQLite + FTS5, no daemon, no bloat",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/help.sh

@@ -22,6 +22,7 @@ echo -e "  ${BOLD}Commands:${RESET}"
 echo -e "    ${CYAN}search${RESET}      Search past sessions, files, and observations"
 echo -e "    ${CYAN}tasks${RESET}       Manage tracked tasks (add, done, block, list)"
 echo -e "    ${CYAN}overview${RESET}    View or set project overview"
+echo -e "    ${CYAN}memories${RESET}    Browse and search Claude Code memories, plans, and tasks"
 echo -e "    ${CYAN}scan${RESET}        Analyze a project and generate an overview"
 echo -e "    ${CYAN}index${RESET}       Index source files for code-level search"
 echo -e "    ${CYAN}prune${RESET}       Remove old observations and orphaned chunks"
@@ -39,6 +40,10 @@ echo -e "    ${DIM}\$${RESET} eagle-mem tasks add \"Fix X\"  ${DIM}# Add a task$
 echo -e "    ${DIM}\$${RESET} eagle-mem overview           ${DIM}# View overview${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem scan .             ${DIM}# Scan current project${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem index .            ${DIM}# Index source files${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem memories           ${DIM}# List mirrored memories${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem memories sync      ${DIM}# Backfill memories + plans + tasks${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem memories plans     ${DIM}# List captured plans${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem memories tasks     ${DIM}# List captured tasks${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem prune              ${DIM}# Clean old data${RESET}"
 echo -e "    ${DIM}\$${RESET} eagle-mem install            ${DIM}# First-time setup${RESET}"
 echo ""
@@ -47,6 +52,7 @@ echo -e "    ${DOT} Saves session summaries to a shared SQLite database"
 echo -e "    ${DOT} Injects relevant memory at session start"
 echo -e "    ${DOT} Searches past sessions when you ask related questions"
 echo -e "    ${DOT} Tracks file operations across sessions"
+echo -e "    ${DOT} Mirrors Claude Code memories, plans, and tasks into FTS5-searchable storage"
 echo -e "    ${DOT} Provides task management for complex multi-step work"
 echo ""
 echo -e "  ${BOLD}Skills${RESET} ${DIM}(available inside Claude Code):${RESET}"

package/scripts/install.sh

@@ -190,7 +190,7 @@ patch_hook "Stop" "" \
     "$EAGLE_MEM_DIR/hooks/stop.sh" \
     "Stop hook"
 
-patch_hook "PostToolUse" "Read|Write|Edit|Bash" \
+patch_hook "PostToolUse" "Read|Write|Edit|Bash|TaskCreate|TaskUpdate" \
     "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
     "PostToolUse hook"
 

package/scripts/memories.sh

@@ -0,0 +1,584 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Claude Code Memory Mirror CLI
+# List, show, search, and sync Claude Code auto-memories
+# ═══════════════════════════════════════════════════════════
+set -euo pipefail
+
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
+
+. "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
+
+eagle_ensure_db
+
+# ─── Parse arguments ──────────────────────────────────────
+
+action="${1:-list}"
+shift 2>/dev/null || true
+
+project=""
+limit=20
+query=""
+
+show_help() {
+    echo -e "  ${BOLD}eagle-mem memories${RESET} — Claude Code memory, plan & task mirror"
+    echo ""
+    echo -e "  ${BOLD}Usage:${RESET}"
+    echo -e "    eagle-mem memories                          ${DIM}# list all mirrored memories${RESET}"
+    echo -e "    eagle-mem memories list                     ${DIM}# same as above${RESET}"
+    echo -e "    eagle-mem memories search ${CYAN}<query>${RESET}           ${DIM}# full-text search memories${RESET}"
+    echo -e "    eagle-mem memories show ${CYAN}<file_path>${RESET}         ${DIM}# show a specific memory${RESET}"
+    echo -e "    eagle-mem memories plans                    ${DIM}# list captured plans${RESET}"
+    echo -e "    eagle-mem memories plans search ${CYAN}<query>${RESET}     ${DIM}# full-text search plans${RESET}"
+    echo -e "    eagle-mem memories plans show ${CYAN}<file_path>${RESET}   ${DIM}# show a specific plan${RESET}"
+    echo -e "    eagle-mem memories tasks                    ${DIM}# list captured tasks${RESET}"
+    echo -e "    eagle-mem memories tasks search ${CYAN}<query>${RESET}     ${DIM}# full-text search tasks${RESET}"
+    echo -e "    eagle-mem memories tasks show ${CYAN}<file_path>${RESET}   ${DIM}# show a specific task${RESET}"
+    echo -e "    eagle-mem memories sync                     ${DIM}# backfill memories + plans + tasks${RESET}"
+    echo ""
+    echo -e "  ${BOLD}Options:${RESET}"
+    echo -e "    ${CYAN}-p, --project${RESET} <name>  Filter by project"
+    echo -e "    ${CYAN}-l, --limit${RESET} <N>       Max results (default: 20)"
+    echo ""
+    echo -e "  ${BOLD}How it works:${RESET}"
+    echo -e "    ${DOT} Eagle Mem intercepts Claude Code's auto-memory, plan, and task writes"
+    echo -e "    ${DOT} All are mirrored into Eagle Mem's SQLite + FTS5"
+    echo -e "    ${DOT} Use ${CYAN}sync${RESET} to backfill items written before mirroring was enabled"
+    echo ""
+    exit 0
+}
+
+plan_action=""
+task_action=""
+
+case "$action" in
+    --help|-h) show_help ;;
+    plans)
+        plan_action="${1:-list}"
+        shift 2>/dev/null || true
+        ;;
+    tasks)
+        task_action="${1:-list}"
+        shift 2>/dev/null || true
+        ;;
+esac
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --project|-p)   project="$2"; shift 2 ;;
+        --limit|-l)     limit="$2"; shift 2 ;;
+        --help|-h)      show_help ;;
+        *)
+            if [ -z "$query" ]; then
+                query="$1"; shift
+            else
+                eagle_err "Unknown option: $1"
+                exit 1
+            fi
+            ;;
+    esac
+done
+
+# ─── Actions ─────────────────────────────────────────────
+
+memories_list() {
+    eagle_header "Memories"
+
+    local result
+    result=$(eagle_list_claude_memories "$project" "$limit")
+
+    if [ -z "$result" ]; then
+        eagle_dim "No mirrored memories found."
+        echo ""
+        eagle_dim "Memories are captured automatically when Claude Code writes to its auto-memory."
+        eagle_dim "Run 'eagle-mem memories sync' to backfill existing memories."
+        echo ""
+        return
+    fi
+
+    local count=0
+    while IFS='|' read -r name mtype desc _fp updated; do
+        [ -z "$name" ] && continue
+        count=$((count + 1))
+
+        local type_color="$DIM"
+        case "$mtype" in
+            user)      type_color="$CYAN" ;;
+            feedback)  type_color="$YELLOW" ;;
+            project)   type_color="$GREEN" ;;
+            reference) type_color="$BLUE" ;;
+        esac
+
+        echo -e "  ${BOLD}${name}${RESET}  ${type_color}[${mtype}]${RESET}"
+        [ -n "$desc" ] && echo -e "    ${DIM}${desc}${RESET}"
+        echo -e "    ${DIM}updated: ${updated}${RESET}"
+        echo ""
+    done <<< "$result"
+
+    eagle_dim "$count memories shown"
+    echo ""
+}
+
+memories_search() {
+    if [ -z "$query" ]; then
+        eagle_err "Usage: eagle-mem memories search <query>"
+        exit 1
+    fi
+
+    eagle_header "Memory Search"
+    eagle_info "Query: $query"
+    echo ""
+
+    local result
+    result=$(eagle_search_claude_memories "$query" "$project" "$limit")
+
+    if [ -z "$result" ]; then
+        eagle_dim "No memories matching '$query'"
+        echo ""
+        return
+    fi
+
+    local count=0
+    while IFS='|' read -r name mtype desc content _fp updated; do
+        [ -z "$name" ] && continue
+        count=$((count + 1))
+
+        local type_color="$DIM"
+        case "$mtype" in
+            user)      type_color="$CYAN" ;;
+            feedback)  type_color="$YELLOW" ;;
+            project)   type_color="$GREEN" ;;
+            reference) type_color="$BLUE" ;;
+        esac
+
+        echo -e "  ${BOLD}${name}${RESET}  ${type_color}[${mtype}]${RESET}"
+        [ -n "$desc" ] && echo -e "    ${DIM}${desc}${RESET}"
+        local snippet
+        snippet=$(printf '%s' "$content" | head -c 200)
+        [ -n "$snippet" ] && echo -e "    ${snippet}"
+        echo -e "    ${DIM}updated: ${updated}${RESET}"
+        echo ""
+    done <<< "$result"
+
+    eagle_dim "$count results"
+    echo ""
+}
+
+memories_show() {
+    if [ -z "$query" ]; then
+        eagle_err "Usage: eagle-mem memories show <file_path>"
+        exit 1
+    fi
+
+    local meta
+    meta=$(eagle_db "SELECT memory_name, memory_type, description, file_path, updated_at, origin_session_id
+                     FROM claude_memories WHERE file_path = '$(eagle_sql_escape "$query")';")
+
+    if [ -z "$meta" ]; then
+        eagle_err "Memory not found: $query"
+        exit 1
+    fi
+
+    IFS='|' read -r name mtype desc fp updated origin <<< "$meta"
+
+    eagle_header "Memory Detail"
+
+    eagle_kv "Name:" "$name"
+    eagle_kv "Type:" "$mtype"
+    eagle_kv "File:" "$fp"
+    eagle_kv "Updated:" "$updated"
+    [ -n "$origin" ] && eagle_kv "Session:" "$origin"
+    echo ""
+
+    [ -n "$desc" ] && echo -e "  ${BOLD}Description:${RESET} $desc"
+    echo ""
+
+    if [ -f "$fp" ]; then
+        echo -e "  ${BOLD}Content:${RESET}"
+        awk '/^---$/{c++; next} c>=2' "$fp" | while IFS= read -r line; do
+            echo "    $line"
+        done
+    else
+        eagle_dim "Source file no longer exists on disk."
+    fi
+    echo ""
+}
+
+plans_list() {
+    eagle_header "Plans"
+
+    local result
+    result=$(eagle_list_claude_plans "$project" "$limit")
+
+    if [ -z "$result" ]; then
+        eagle_dim "No captured plans found."
+        echo ""
+        eagle_dim "Plans are captured when Claude Code writes to ~/.claude/plans/"
+        eagle_dim "Run 'eagle-mem memories sync' to backfill existing plans."
+        echo ""
+        return
+    fi
+
+    local count=0
+    while IFS='|' read -r title proj _fp updated; do
+        [ -z "$title" ] && continue
+        count=$((count + 1))
+
+        local proj_label=""
+        [ -n "$proj" ] && proj_label="  ${DIM}[${proj}]${RESET}"
+
+        echo -e "  ${BOLD}${title}${RESET}${proj_label}"
+        echo -e "    ${DIM}updated: ${updated}${RESET}"
+        echo ""
+    done <<< "$result"
+
+    eagle_dim "$count plans shown"
+    echo ""
+}
+
+plans_search() {
+    if [ -z "$query" ]; then
+        eagle_err "Usage: eagle-mem memories plans search <query>"
+        exit 1
+    fi
+
+    eagle_header "Plan Search"
+    eagle_info "Query: $query"
+    echo ""
+
+    local result
+    result=$(eagle_search_claude_plans "$query" "$project" "$limit")
+
+    if [ -z "$result" ]; then
+        eagle_dim "No plans matching '$query'"
+        echo ""
+        return
+    fi
+
+    local count=0
+    while IFS='|' read -r title proj snippet _fp updated; do
+        [ -z "$title" ] && continue
+        count=$((count + 1))
+
+        local proj_label=""
+        [ -n "$proj" ] && proj_label="  ${DIM}[${proj}]${RESET}"
+
+        echo -e "  ${BOLD}${title}${RESET}${proj_label}"
+        [ -n "$snippet" ] && echo -e "    ${snippet}"
+        echo -e "    ${DIM}updated: ${updated}${RESET}"
+        echo ""
+    done <<< "$result"
+
+    eagle_dim "$count results"
+    echo ""
+}
+
+plans_show() {
+    if [ -z "$query" ]; then
+        eagle_err "Usage: eagle-mem memories plans show <file_path>"
+        exit 1
+    fi
+
+    local meta
+    meta=$(eagle_db "SELECT title, project, file_path, updated_at, origin_session_id
+                     FROM claude_plans WHERE file_path = '$(eagle_sql_escape "$query")';")
+
+    if [ -z "$meta" ]; then
+        eagle_err "Plan not found: $query"
+        exit 1
+    fi
+
+    IFS='|' read -r title proj fp updated origin <<< "$meta"
+
+    eagle_header "Plan Detail"
+
+    eagle_kv "Title:" "$title"
+    [ -n "$proj" ] && eagle_kv "Project:" "$proj"
+    eagle_kv "File:" "$fp"
+    eagle_kv "Updated:" "$updated"
+    [ -n "$origin" ] && eagle_kv "Session:" "$origin"
+    echo ""
+
+    if [ -f "$fp" ]; then
+        echo -e "  ${BOLD}Content:${RESET}"
+        cat "$fp" | while IFS= read -r line; do
+            echo "    $line"
+        done
+    else
+        eagle_dim "Source file no longer exists on disk."
+    fi
+    echo ""
+}
+
+tasks_list() {
+    eagle_header "Claude Code Tasks"
+
+    local result
+    result=$(eagle_list_claude_tasks "$project" "$limit")
+
+    if [ -z "$result" ]; then
+        eagle_dim "No captured tasks found."
+        echo ""
+        eagle_dim "Tasks are captured when Claude Code uses TaskCreate/TaskUpdate."
+        eagle_dim "Run 'eagle-mem memories sync' to backfill existing tasks."
+        echo ""
+        return
+    fi
+
+    local count=0
+    while IFS='|' read -r subject status sid tid updated; do
+        [ -z "$subject" ] && continue
+        count=$((count + 1))
+
+        local status_color="$DIM"
+        case "$status" in
+            pending)     status_color="$DIM" ;;
+            in_progress) status_color="$CYAN" ;;
+            completed)   status_color="$GREEN" ;;
+        esac
+
+        echo -e "  ${BOLD}${subject}${RESET}  ${status_color}[${status}]${RESET}"
+        echo -e "    ${DIM}session: ${sid:0:8}…  task: #${tid}  updated: ${updated}${RESET}"
+        echo ""
+    done <<< "$result"
+
+    eagle_dim "$count tasks shown"
+    echo ""
+}
+
+tasks_search() {
+    if [ -z "$query" ]; then
+        eagle_err "Usage: eagle-mem memories tasks search <query>"
+        exit 1
+    fi
+
+    eagle_header "Task Search"
+    eagle_info "Query: $query"
+    echo ""
+
+    local result
+    result=$(eagle_search_claude_tasks "$query" "$project" "$limit")
+
+    if [ -z "$result" ]; then
+        eagle_dim "No tasks matching '$query'"
+        echo ""
+        return
+    fi
+
+    local count=0
+    while IFS='|' read -r subject status desc sid tid updated; do
+        [ -z "$subject" ] && continue
+        count=$((count + 1))
+
+        local status_color="$DIM"
+        case "$status" in
+            pending)     status_color="$DIM" ;;
+            in_progress) status_color="$CYAN" ;;
+            completed)   status_color="$GREEN" ;;
+        esac
+
+        echo -e "  ${BOLD}${subject}${RESET}  ${status_color}[${status}]${RESET}"
+        [ -n "$desc" ] && echo -e "    ${desc}"
+        echo -e "    ${DIM}session: ${sid:0:8}…  task: #${tid}  updated: ${updated}${RESET}"
+        echo ""
+    done <<< "$result"
+
+    eagle_dim "$count results"
+    echo ""
+}
+
+tasks_show() {
+    if [ -z "$query" ]; then
+        eagle_err "Usage: eagle-mem memories tasks show <file_path>"
+        exit 1
+    fi
+
+    local meta
+    meta=$(eagle_db "SELECT subject, status, description, active_form, source_session_id, source_task_id, file_path, updated_at
+                     FROM claude_tasks WHERE file_path = '$(eagle_sql_escape "$query")';")
+
+    if [ -z "$meta" ]; then
+        eagle_err "Task not found: $query"
+        exit 1
+    fi
+
+    IFS='|' read -r subject status desc af sid tid fp updated <<< "$meta"
+
+    eagle_header "Task Detail"
+
+    eagle_kv "Subject:" "$subject"
+    eagle_kv "Status:" "$status"
+    eagle_kv "Task ID:" "$tid"
+    eagle_kv "Session:" "$sid"
+    eagle_kv "File:" "$fp"
+    eagle_kv "Updated:" "$updated"
+    echo ""
+
+    [ -n "$desc" ] && echo -e "  ${BOLD}Description:${RESET} $desc" && echo ""
+    [ -n "$af" ] && echo -e "  ${BOLD}Active Form:${RESET} $af" && echo ""
+
+    if [ -f "$fp" ]; then
+        echo -e "  ${BOLD}Raw JSON:${RESET}"
+        jq '.' "$fp" 2>/dev/null | while IFS= read -r line; do
+            echo "    $line"
+        done
+    else
+        eagle_dim "Source file no longer exists on disk."
+    fi
+    echo ""
+}
+
+memories_sync() {
+    eagle_header "Memory, Plan & Task Sync"
+
+    # ─── Sync memories ───────────────────────────────────
+    eagle_info "Scanning for Claude Code auto-memory files..."
+    echo ""
+
+    local claude_mem_root="$HOME/.claude/projects"
+    local mem_synced=0
+    local mem_skipped=0
+
+    if [ -d "$claude_mem_root" ]; then
+        while IFS= read -r -d '' memfile; do
+            local base
+            base=$(basename "$memfile")
+            [ "$base" = "MEMORY.md" ] && continue
+
+            local existing_hash
+            existing_hash=$(eagle_db "SELECT content_hash FROM claude_memories WHERE file_path = '$(eagle_sql_escape "$memfile")';")
+            local new_hash
+            new_hash=$(shasum -a 256 "$memfile" | awk '{print $1}')
+
+            if [ "$existing_hash" = "$new_hash" ]; then
+                mem_skipped=$((mem_skipped + 1))
+                continue
+            fi
+
+            eagle_capture_claude_memory "$memfile" "" ""
+            mem_synced=$((mem_synced + 1))
+            eagle_ok "Memory: $base"
+        done < <(find "$claude_mem_root" -path "*/memory/*.md" -print0 2>/dev/null)
+    fi
+
+    eagle_kv "Memories:" "$mem_synced synced, $mem_skipped unchanged"
+    echo ""
+
+    # ─── Sync plans ──────────────────────────────────────
+    eagle_info "Scanning for Claude Code plan files..."
+    echo ""
+
+    local plans_dir="$HOME/.claude/plans"
+    local plan_synced=0
+    local plan_skipped=0
+
+    if [ -d "$plans_dir" ]; then
+        for planfile in "$plans_dir"/*.md; do
+            [ ! -f "$planfile" ] && continue
+
+            local existing_hash
+            existing_hash=$(eagle_db "SELECT content_hash FROM claude_plans WHERE file_path = '$(eagle_sql_escape "$planfile")';")
+            local new_hash
+            new_hash=$(shasum -a 256 "$planfile" | awk '{print $1}')
+
+            if [ "$existing_hash" = "$new_hash" ]; then
+                plan_skipped=$((plan_skipped + 1))
+                continue
+            fi
+
+            eagle_capture_claude_plan "$planfile" "" ""
+            plan_synced=$((plan_synced + 1))
+            local ptitle
+            ptitle=$(awk '/^# /{print; exit}' "$planfile" | sed 's/^# //')
+            eagle_ok "Plan: $ptitle"
+        done
+    fi
+
+    eagle_kv "Plans:" "$plan_synced synced, $plan_skipped unchanged"
+    echo ""
+
+    # ─── Sync tasks ──────────────────────────────────────
+    eagle_info "Scanning for Claude Code task files..."
+    echo ""
+
+    local tasks_dir="$HOME/.claude/tasks"
+    local task_synced=0
+    local task_skipped=0
+
+    if [ -d "$tasks_dir" ]; then
+        for session_dir in "$tasks_dir"/*/; do
+            [ ! -d "$session_dir" ] && continue
+            local sid
+            sid=$(basename "$session_dir")
+
+            local task_project=""
+            task_project=$(eagle_db "SELECT project FROM sessions WHERE id = '$(eagle_sql_escape "$sid")' LIMIT 1;")
+
+            for taskfile in "$session_dir"*.json; do
+                [ ! -f "$taskfile" ] && continue
+
+                local existing_hash
+                existing_hash=$(eagle_db "SELECT content_hash FROM claude_tasks WHERE file_path = '$(eagle_sql_escape "$taskfile")';")
+                local new_hash
+                new_hash=$(shasum -a 256 "$taskfile" | awk '{print $1}')
+
+                if [ "$existing_hash" = "$new_hash" ]; then
+                    task_skipped=$((task_skipped + 1))
+                    continue
+                fi
+
+                eagle_capture_claude_task "$taskfile" "$sid" "$task_project"
+                task_synced=$((task_synced + 1))
+            done
+        done
+    fi
+
+    eagle_kv "Tasks:" "$task_synced synced, $task_skipped unchanged"
+    echo ""
+
+    # ─── Backfill project names ──────────────────────────
+    eagle_info "Resolving project names from Claude Code transcripts..."
+
+    local backfilled
+    backfilled=$(eagle_backfill_projects)
+    if [ "${backfilled:-0}" -gt 0 ]; then
+        eagle_ok "$backfilled rows updated with correct project names"
+    else
+        eagle_ok "All project names up to date"
+    fi
+
+    eagle_footer "Sync complete."
+}
+
+# ─── Dispatch ────────────────────────────────────────────
+
+case "$action" in
+    list)    memories_list ;;
+    search)  memories_search ;;
+    show)    memories_show ;;
+    plans)
+        case "$plan_action" in
+            list)    plans_list ;;
+            search)  plans_search ;;
+            show)    plans_show ;;
+            *)       plans_list ;;
+        esac
+        ;;
+    tasks)
+        case "$task_action" in
+            list)    tasks_list ;;
+            search)  tasks_search ;;
+            show)    tasks_show ;;
+            *)       tasks_list ;;
+        esac
+        ;;
+    sync)    memories_sync ;;
+    *)
+        eagle_err "Unknown action: $action"
+        echo -e "  ${DIM}Available: list, search, show, plans, tasks, sync${RESET}"
+        exit 1
+        ;;
+esac

package/scripts/update.sh

@@ -11,6 +11,7 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 
 . "$SCRIPTS_DIR/style.sh"
 . "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
 
@@ -79,7 +80,12 @@ if [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
 
     patch_hook "SessionStart" "" "$EAGLE_MEM_DIR/hooks/session-start.sh"
     patch_hook "Stop" "" "$EAGLE_MEM_DIR/hooks/stop.sh"
-    patch_hook "PostToolUse" "Read|Write|Edit|Bash" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
+    # Update PostToolUse matcher if it has the old value (pre-v1.3.0)
+    if jq -e '.hooks.PostToolUse[]? | select(.matcher == "Read|Write|Edit|Bash")' "$SETTINGS" &>/dev/null; then
+        _tmp=$(mktemp)
+        jq '(.hooks.PostToolUse[] | select(.matcher == "Read|Write|Edit|Bash")).matcher = "Read|Write|Edit|Bash|TaskCreate|TaskUpdate"' "$SETTINGS" > "$_tmp" && mv "$_tmp" "$SETTINGS"
+    fi
+    patch_hook "PostToolUse" "Read|Write|Edit|Bash|TaskCreate|TaskUpdate" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     patch_hook "SessionEnd" "" "$EAGLE_MEM_DIR/hooks/session-end.sh"
     patch_hook "UserPromptSubmit" "" "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh"
 
@@ -100,6 +106,15 @@ if [ -d "$PACKAGE_DIR/skills" ]; then
     eagle_ok "Skills updated"
 fi
 
+# ─── Backfill project names ───────────────────────────────
+
+backfilled=$(eagle_backfill_projects 2>/dev/null)
+if [ "${backfilled:-0}" -gt 0 ]; then
+    eagle_ok "Project names: $backfilled rows corrected"
+else
+    eagle_ok "Project names up to date"
+fi
+
 # ─── Summary ───────────────────────────────────────────────
 
 version=$(node -e "console.log(require('$PACKAGE_DIR/package.json').version)" 2>/dev/null || echo "unknown")