eagle-mem 4.7.0 → 4.7.1

package/scripts/search.sh

@@ -26,7 +26,7 @@ show_help() {
     echo -e "    eagle-mem search ${CYAN}--files${RESET}                  ${DIM}# frequently modified files${RESET}"
     echo -e "    eagle-mem search ${CYAN}--stats${RESET}                  ${DIM}# project statistics${RESET}"
     echo -e "    eagle-mem search ${CYAN}--overview${RESET}                ${DIM}# project overview${RESET}"
-    echo -e "    eagle-mem search ${CYAN}--memories${RESET}               ${DIM}# mirrored Claude memories${RESET}"
+    echo -e "    eagle-mem search ${CYAN}--memories${RESET}               ${DIM}# mirrored agent memories${RESET}"
     echo -e "    eagle-mem search ${CYAN}--tasks${RESET}                  ${DIM}# in-flight tasks${RESET}"
     echo ""
     echo -e "  ${BOLD}Options:${RESET}"
@@ -269,7 +269,7 @@ search_stats() {
     sessions_codex=$(eagle_db "SELECT COUNT(*) FROM sessions WHERE project = '$p' AND agent = 'codex';")
     summaries=$(eagle_db "SELECT COUNT(*) FROM summaries WHERE project = '$p';")
     observations=$(eagle_db "SELECT COUNT(*) FROM observations o JOIN sessions s ON s.id = o.session_id WHERE s.project = '$p';")
-    tasks=$(eagle_db "SELECT COUNT(*) FROM claude_tasks WHERE project = '$p';")
+    tasks=$(eagle_db "SELECT COUNT(*) FROM agent_tasks WHERE project = '$p';")
     local chunks
     chunks=$(eagle_db "SELECT COUNT(*) FROM code_chunks WHERE project = '$p';")
 
@@ -349,15 +349,15 @@ search_memories() {
             exit 1
         fi
         local q; q=$(eagle_sql_escape "$sanitized_mq")
-        local where_match="WHERE claude_memories_fts MATCH '$q'"
+        local where_match="WHERE agent_memories_fts MATCH '$q'"
         if [ "$cross_project" = false ]; then
             where_match="$where_match AND m.project = '$p'"
         fi
 
         if [ "$json_output" = true ]; then
             eagle_db_json "SELECT m.memory_name, m.memory_type, m.description, m.project, m.updated_at, m.origin_agent
-                           FROM claude_memories m
-                           JOIN claude_memories_fts f ON f.rowid = m.id
+                           FROM agent_memories m
+                           JOIN agent_memories_fts f ON f.rowid = m.id
                            $where_match
                            ORDER BY rank
                            LIMIT $limit;"
@@ -366,8 +366,8 @@ search_memories() {
 
         local results
         results=$(eagle_db "SELECT m.memory_name, m.memory_type, m.description, m.project, m.updated_at, m.origin_agent
-                            FROM claude_memories m
-                            JOIN claude_memories_fts f ON f.rowid = m.id
+                            FROM agent_memories m
+                            JOIN agent_memories_fts f ON f.rowid = m.id
                             $where_match
                             ORDER BY rank
                             LIMIT $limit;")
@@ -390,14 +390,14 @@ search_memories() {
 
     if [ "$json_output" = true ]; then
         eagle_db_json "SELECT memory_name, memory_type, description, project, updated_at, origin_agent
-                       FROM claude_memories $where_project
+                       FROM agent_memories $where_project
                        ORDER BY updated_at DESC LIMIT $limit;"
         return
     fi
 
     local results
     results=$(eagle_db "SELECT memory_name, memory_type, description, updated_at, origin_agent
-                        FROM claude_memories $where_project
+                        FROM agent_memories $where_project
                         ORDER BY updated_at DESC LIMIT $limit;")
 
     if [ -z "$results" ]; then
@@ -424,8 +424,10 @@ search_tasks() {
     local p; p=$(eagle_sql_escape "$project")
 
     local where_project=""
+    local where_task_project=""
     if [ "$cross_project" = false ]; then
         where_project="AND project = '$p'"
+        where_task_project="AND t.project = '$p'"
     fi
 
     if [ -n "$query" ]; then
@@ -439,10 +441,10 @@ search_tasks() {
 
         if [ "$json_output" = true ]; then
             eagle_db_json "SELECT t.subject, t.status, t.project, t.updated_at, t.origin_agent
-                           FROM claude_tasks t
-                           JOIN claude_tasks_fts f ON f.rowid = t.id
-                           WHERE claude_tasks_fts MATCH '$q'
-                           ${where_project/AND/AND t.}
+                           FROM agent_tasks t
+                           JOIN agent_tasks_fts f ON f.rowid = t.id
+                           WHERE agent_tasks_fts MATCH '$q'
+                           $where_task_project
                            ORDER BY rank
                            LIMIT $limit;"
             return
@@ -450,10 +452,10 @@ search_tasks() {
 
         local results
         results=$(eagle_db "SELECT t.subject, t.status, t.project, t.updated_at, t.origin_agent
-                            FROM claude_tasks t
-                            JOIN claude_tasks_fts f ON f.rowid = t.id
-                            WHERE claude_tasks_fts MATCH '$q'
-                            ${where_project/AND/AND t.}
+                            FROM agent_tasks t
+                            JOIN agent_tasks_fts f ON f.rowid = t.id
+                            WHERE agent_tasks_fts MATCH '$q'
+                            $where_task_project
                             ORDER BY rank
                             LIMIT $limit;")
 
@@ -479,7 +481,7 @@ search_tasks() {
 
     if [ "$json_output" = true ]; then
         eagle_db_json "SELECT subject, status, project, updated_at, origin_agent
-                       FROM claude_tasks
+                       FROM agent_tasks
                        WHERE status IN ('in_progress', 'pending')
                        $where_project
                        ORDER BY CASE status WHEN 'in_progress' THEN 0 ELSE 1 END, updated_at DESC
@@ -489,7 +491,7 @@ search_tasks() {
 
     local results
     results=$(eagle_db "SELECT subject, status, updated_at, origin_agent
-                        FROM claude_tasks
+                        FROM agent_tasks
                         WHERE status IN ('in_progress', 'pending')
                         $where_project
                         ORDER BY CASE status WHEN 'in_progress' THEN 0 ELSE 1 END, updated_at DESC

package/scripts/statusline-em.sh

@@ -21,7 +21,7 @@ eagle_mem_statusline() {
     cnt=$(echo ".headers off
 SELECT COUNT(*) FROM sessions WHERE project = '${proj}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
     mem=$(echo ".headers off
-SELECT COUNT(*) FROM claude_memories WHERE project = '${proj}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
+SELECT COUNT(*) FROM agent_memories WHERE project = '${proj}';" | sqlite3 "$em_db" 2>/dev/null | tr -d '[:space:]')
     cnt=${cnt:-0}; mem=${mem:-0}
 
     local R='\033[0m' CYAN='\033[96m' WHT='\033[97m' DIM='\033[2m'

package/scripts/tasks.sh

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 # ═══════════════════════════════════════════════════════════
-# Eagle Mem — Tasks (read-only viewer of Claude Code tasks)
-# Claude Code manages task state via TaskCreate/TaskUpdate;
-# Eagle Mem mirrors it and displays it here.
+# Eagle Mem — Tasks
+# Mirrors native task state and lets agents without native task files persist
+# task handoff records directly.
 # ═══════════════════════════════════════════════════════════
 set -euo pipefail
 
@@ -26,22 +26,29 @@ esac
 
 project=""
 json_output=false
+agent=""
 
 show_help() {
-    echo -e "  ${BOLD}eagle-mem tasks${RESET} — View mirrored Claude Code tasks"
+    echo -e "  ${BOLD}eagle-mem tasks${RESET} — View mirrored agent tasks"
     echo ""
     echo -e "  ${BOLD}Usage:${RESET}"
     echo -e "    eagle-mem tasks                  ${DIM}# list pending/in-progress tasks${RESET}"
     echo -e "    eagle-mem tasks ${CYAN}list${RESET}             ${DIM}# list all tasks${RESET}"
     echo -e "    eagle-mem tasks ${CYAN}completed${RESET}        ${DIM}# list completed tasks${RESET}"
     echo -e "    eagle-mem tasks ${CYAN}search${RESET} <query>   ${DIM}# search tasks by keyword${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}add${RESET} <subject>    ${DIM}# create a persistent task record${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}update${RESET} <id>      ${DIM}# update subject/description/status${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}start${RESET} <id>       ${DIM}# mark task in_progress${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}complete${RESET} <id>    ${DIM}# mark task completed${RESET}"
+    echo -e "    eagle-mem tasks ${CYAN}cancel${RESET} <id>      ${DIM}# mark task cancelled${RESET}"
     echo ""
     echo -e "  ${BOLD}Options:${RESET}"
     echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
+    echo -e "    ${CYAN}--agent${RESET} <name>          Source agent (codex or claude-code)"
     echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
     echo ""
-    echo -e "  ${DIM}Tasks are managed by Claude Code (TaskCreate/TaskUpdate).${RESET}"
-    echo -e "  ${DIM}Eagle Mem automatically mirrors them for cross-session recall.${RESET}"
+    echo -e "  ${DIM}Claude Code task files are mirrored automatically.${RESET}"
+    echo -e "  ${DIM}Codex can persist tasks with this CLI when using the eagle-mem-tasks skill.${RESET}"
     echo ""
     exit 0
 }
@@ -50,6 +57,7 @@ args=()
 while [ $# -gt 0 ]; do
     case "$1" in
         --project|-p)   project="$2"; shift 2 ;;
+        --agent)        agent="$2"; shift 2 ;;
         --json|-j)      json_output=true; shift ;;
         --help|-h)      show_help ;;
         *)  args+=("$1"); shift ;;
@@ -58,6 +66,8 @@ done
 
 [ -z "$project" ] && project=$(eagle_project_from_cwd "$(pwd)")
 project_sql=$(eagle_sql_escape "$project")
+[ -z "$agent" ] && agent=$(eagle_agent_source)
+agent_sql=$(eagle_sql_escape "$agent")
 
 # ─── List tasks ───────────────────────────────────────────
 
@@ -73,7 +83,7 @@ tasks_list() {
 
     if [ "$json_output" = true ]; then
         eagle_db_json "SELECT source_task_id, subject, description, status, blocks, blocked_by, updated_at
-                       FROM claude_tasks
+                       FROM agent_tasks
                        WHERE project = '$project_sql' $where_status
                        ORDER BY updated_at DESC
                        LIMIT 20;"
@@ -82,7 +92,7 @@ tasks_list() {
 
     local results
     results=$(eagle_db "SELECT source_task_id, subject, status, blocked_by, description
-                        FROM claude_tasks
+                        FROM agent_tasks
                         WHERE project = '$project_sql' $where_status
                         ORDER BY
                             CASE status WHEN 'in_progress' THEN 0 WHEN 'pending' THEN 1 ELSE 2 END,
@@ -106,7 +116,7 @@ tasks_list() {
             in_progress) icon="${CYAN}>${RESET}"; marker=" ${CYAN}[in_progress]${RESET}" ;;
             pending)     icon="${DIM}o${RESET}"; marker="" ;;
             completed)   icon="${GREEN}+${RESET}"; marker=" ${DIM}[completed]${RESET}" ;;
-            deleted)     icon="${RED}x${RESET}"; marker=" ${RED}[deleted]${RESET}" ;;
+            cancelled)   icon="${RED}x${RESET}"; marker=" ${RED}[cancelled]${RESET}" ;;
             *)           icon="$DOT"; marker="" ;;
         esac
         if [ "$blocked_by" != "[]" ] && [ -n "$blocked_by" ]; then
@@ -137,9 +147,9 @@ tasks_search() {
     if [ "$json_output" = true ]; then
         local query_sql; query_sql=$(eagle_sql_escape "$sanitized_query")
         eagle_db_json "SELECT t.source_task_id, t.subject, t.status, t.description, t.updated_at
-                       FROM claude_tasks t
-                       JOIN claude_tasks_fts f ON f.rowid = t.id
-                       WHERE claude_tasks_fts MATCH '$query_sql'
+                       FROM agent_tasks t
+                       JOIN agent_tasks_fts f ON f.rowid = t.id
+                       WHERE agent_tasks_fts MATCH '$query_sql'
                        AND t.project = '$project_sql'
                        ORDER BY rank
                        LIMIT 10;"
@@ -149,9 +159,9 @@ tasks_search() {
     local results
     local query_sql; query_sql=$(eagle_sql_escape "$sanitized_query")
     results=$(eagle_db "SELECT t.source_task_id, t.subject, t.status, t.description
-                        FROM claude_tasks t
-                        JOIN claude_tasks_fts f ON f.rowid = t.id
-                        WHERE claude_tasks_fts MATCH '$query_sql'
+                        FROM agent_tasks t
+                        JOIN agent_tasks_fts f ON f.rowid = t.id
+                        WHERE agent_tasks_fts MATCH '$query_sql'
                         AND t.project = '$project_sql'
                         ORDER BY rank
                         LIMIT 10;")
@@ -174,6 +184,162 @@ tasks_search() {
     echo ""
 }
 
+# ─── Mutate task records ──────────────────────────────────
+
+tasks_add() {
+    local subject="${args[0]:-}"
+    if [ -z "$subject" ]; then
+        eagle_err "Usage: eagle-mem tasks add <subject> [--desc <text>] [--status pending|in_progress]"
+        exit 1
+    fi
+
+    local desc=""
+    local status="pending"
+    local i=1
+    while [ "$i" -lt "${#args[@]}" ]; do
+        case "${args[$i]}" in
+            --desc|-d)
+                i=$((i + 1))
+                desc="${args[$i]:-}"
+                ;;
+            --status)
+                i=$((i + 1))
+                status="${args[$i]:-pending}"
+                ;;
+        esac
+        i=$((i + 1))
+    done
+
+    case "$status" in
+        pending|in_progress|completed|cancelled) ;;
+        *)
+            eagle_err "Invalid status: $status"
+            exit 1
+            ;;
+    esac
+
+    local task_id file_path content_hash
+    task_id="agent-$(date -u +%Y%m%d%H%M%S)-$$"
+    file_path="agent-task://$project/$task_id"
+    content_hash=$(printf '%s|%s|%s|%s' "$subject" "$desc" "$status" "$agent" | shasum -a 256 | awk '{print $1}')
+
+    local tid_sql fp_sql subj_sql desc_sql status_sql hash_sql
+    tid_sql=$(eagle_sql_escape "$task_id")
+    fp_sql=$(eagle_sql_escape "$file_path")
+    subj_sql=$(eagle_sql_escape "$subject")
+    desc_sql=$(eagle_sql_escape "$desc")
+    status_sql=$(eagle_sql_escape "$status")
+    hash_sql=$(eagle_sql_escape "$content_hash")
+
+    eagle_db_pipe <<SQL
+INSERT INTO agent_tasks (project, source_session_id, source_task_id, file_path, subject, description, active_form, status, blocks, blocked_by, content_hash, origin_agent)
+VALUES ('$project_sql', 'manual', '$tid_sql', '$fp_sql', '$subj_sql', '$desc_sql', '', '$status_sql', '[]', '[]', '$hash_sql', '$agent_sql');
+SQL
+
+    if [ "$json_output" = true ]; then
+        jq -nc --arg id "$task_id" --arg subject "$subject" --arg status "$status" --arg agent "$agent" \
+            '{source_task_id:$id, subject:$subject, status:$status, origin_agent:$agent}'
+    else
+        eagle_ok "Task '$task_id' created"
+    fi
+}
+
+tasks_set_status() {
+    local task_id="${args[0]:-}"
+    local status="$1"
+    if [ -z "$task_id" ]; then
+        eagle_err "Usage: eagle-mem tasks $action <id>"
+        exit 1
+    fi
+
+    local tid_sql status_sql
+    tid_sql=$(eagle_sql_escape "$task_id")
+    status_sql=$(eagle_sql_escape "$status")
+
+    changed=$(eagle_db_pipe <<SQL
+UPDATE agent_tasks
+SET status = '$status_sql',
+    origin_agent = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE project = '$project_sql' AND source_task_id = '$tid_sql';
+SELECT changes();
+SQL
+)
+
+    if [ "${changed:-0}" -gt 0 ] 2>/dev/null; then
+        eagle_ok "Task '$task_id' marked $status"
+    else
+        eagle_err "Task not found: $task_id"
+        exit 1
+    fi
+}
+
+tasks_update() {
+    local task_id="${args[0]:-}"
+    if [ -z "$task_id" ]; then
+        eagle_err "Usage: eagle-mem tasks update <id> [--subject <text>] [--desc <text>] [--status <status>]"
+        exit 1
+    fi
+
+    local subject="" desc="" status=""
+    local i=1
+    while [ "$i" -lt "${#args[@]}" ]; do
+        case "${args[$i]}" in
+            --subject)
+                i=$((i + 1))
+                subject="${args[$i]:-}"
+                ;;
+            --desc|-d)
+                i=$((i + 1))
+                desc="${args[$i]:-}"
+                ;;
+            --status)
+                i=$((i + 1))
+                status="${args[$i]:-}"
+                ;;
+        esac
+        i=$((i + 1))
+    done
+
+    if [ -n "$status" ]; then
+        case "$status" in
+            pending|in_progress|completed|cancelled) ;;
+            *)
+                eagle_err "Invalid status: $status"
+                exit 1
+                ;;
+        esac
+    fi
+
+    local tid_sql subj_sql desc_sql status_sql hash_sql
+    tid_sql=$(eagle_sql_escape "$task_id")
+    subj_sql=$(eagle_sql_escape "$subject")
+    desc_sql=$(eagle_sql_escape "$desc")
+    status_sql=$(eagle_sql_escape "$status")
+    hash_sql=$(printf '%s|%s|%s|%s|%s' "$task_id" "$subject" "$desc" "$status" "$agent" | shasum -a 256 | awk '{print $1}')
+    hash_sql=$(eagle_sql_escape "$hash_sql")
+
+    changed=$(eagle_db_pipe <<SQL
+UPDATE agent_tasks
+SET subject = CASE WHEN '$subj_sql' != '' THEN '$subj_sql' ELSE subject END,
+    description = CASE WHEN '$desc_sql' != '' THEN '$desc_sql' ELSE description END,
+    status = CASE WHEN '$status_sql' != '' THEN '$status_sql' ELSE status END,
+    origin_agent = COALESCE(NULLIF('$agent_sql', ''), origin_agent),
+    content_hash = '$hash_sql',
+    updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE project = '$project_sql' AND source_task_id = '$tid_sql';
+SELECT changes();
+SQL
+)
+
+    if [ "${changed:-0}" -gt 0 ] 2>/dev/null; then
+        eagle_ok "Task '$task_id' updated"
+    else
+        eagle_err "Task not found: $task_id"
+        exit 1
+    fi
+}
+
 # ─── Dispatch ─────────────────────────────────────────────
 
 case "$action" in
@@ -181,6 +347,11 @@ case "$action" in
     pending)    tasks_list "pending" ;;
     completed)  tasks_list "completed" ;;
     search)     tasks_search ;;
+    add)        tasks_add ;;
+    update)     tasks_update ;;
+    start)      tasks_set_status "in_progress" ;;
+    complete)   tasks_set_status "completed" ;;
+    cancel)     tasks_set_status "cancelled" ;;
     --help|-h)  show_help ;;
     *)
         eagle_err "Unknown action: $action"

package/scripts/update.sh

@@ -119,7 +119,26 @@ if [ "$claude_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
         [ -L "$dst" ] && rm "$dst"
         ln -sf "$skill_dir" "$dst"
     done
-    eagle_ok "Skills updated"
+    eagle_ok "Claude skills updated"
+fi
+
+if [ "$codex_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
+    mkdir -p "$EAGLE_CODEX_SKILLS_DIR"
+    find "$EAGLE_CODEX_SKILLS_DIR" -maxdepth 1 -name "eagle-mem-*" -type l 2>/dev/null | while read -r existing; do
+        skill_name=$(basename "$existing")
+        if [ ! -d "$PACKAGE_DIR/skills/$skill_name" ]; then
+            rm "$existing"
+            eagle_ok "Removed stale Codex skill: $skill_name"
+        fi
+    done
+    for skill_dir in "$PACKAGE_DIR"/skills/*/; do
+        [ ! -d "$skill_dir" ] && continue
+        skill_name=$(basename "$skill_dir")
+        dst="$EAGLE_CODEX_SKILLS_DIR/$skill_name"
+        [ -L "$dst" ] && rm "$dst"
+        ln -sf "$skill_dir" "$dst"
+    done
+    eagle_ok "Codex skills updated"
 fi
 
 # ─── Backfill project names ───────────────────────────────

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

@@ -1,8 +1,8 @@
 ---
 name: eagle-mem-memories
 description: >
-  View and sync Claude Code auto-memories, plans, and tasks mirrored in Eagle Mem. Use when:
-  'eagle memories', 'show memories', 'sync memories', 'what does claude remember',
+  View and sync Claude Code and Codex memories, plans, and tasks mirrored in Eagle Mem. Use when:
+  'eagle memories', 'show memories', 'sync memories', 'what does the agent remember',
   'show plans', 'show tasks', 'mirror memories', 'onboard project',
   'what did past sessions learn'. Uses the eagle-mem CLI.
 ---
@@ -11,9 +11,9 @@ description: >
 
 ## Purpose
 
-**For the user:** Claude Code remembers across sessions. Decisions, preferences, project context, and architectural plans survive session boundaries. The user never has to re-explain "we chose Postgres because..." or "don't use semicolons in this project."
+**For the user:** Claude Code and Codex remember across sessions. Decisions, preferences, project context, and architectural plans survive session boundaries. The user never has to re-explain "we chose Postgres because..." or "don't use semicolons in this project."
 
-**For you (Claude Code):** Access to what past Claude sessions learned about this project. Memories tell you *why* decisions were made. Plans tell you *what's coming*. Tasks tell you *what's in flight*. Together they're the knowledge bridge that makes you effective from message one.
+**For you:** Access to what past Claude Code and Codex sessions learned about this project. Memories tell you *why* decisions were made. Plans tell you *what's coming*. Tasks tell you *what's in flight*. Together they're the knowledge bridge that makes you effective from message one.
 
 ## Judgment
 
@@ -21,7 +21,7 @@ description: >
 - The user references a past decision ("remember when we decided to...", "what's our convention for...")
 - You're about to make an architectural or style choice -- memories may record the user's preference
 - You need project context that isn't in CLAUDE.md or README (relationships between services, deployment quirks, naming conventions)
-- The user asks "what does Claude remember about X?"
+- The user asks "what does Claude/Codex/Eagle Mem remember about X?"
 
 **Check plans when:**
 - The user asks about upcoming work or roadmap
@@ -43,21 +43,21 @@ description: >
 
 ### 1. Know the three data types
 
-**Memories** -- Claude Code's auto-memory files (`~/.claude/projects/*/memory/*.md`). These contain user preferences, project conventions, and feedback. Each has a name, type (user/feedback/project/reference), and description.
+**Memories** -- Claude Code auto-memory files (`~/.claude/projects/*/memory/*.md`) plus top-level Codex memory files (`~/.codex/memories/MEMORY.md`, `memory_summary.md`). These contain user preferences, project conventions, and feedback. Each mirrored row is source-attributed.
 ```bash
 eagle-mem memories list                    # all memories
 eagle-mem memories search "typescript"     # FTS5 search
 eagle-mem memories show <file_path>        # full content
 ```
 
-**Plans** -- Claude Code's plan files (`~/.claude/plans/*.md`). Multi-step strategies for complex work. Each has a title, optional project tag, and markdown content.
+**Plans** -- Claude Code plan files (`~/.claude/plans/*.md`) and future agent plan files as support is added. Multi-step strategies for complex work. Each has a title, optional project tag, and markdown content.
 ```bash
 eagle-mem memories plans                   # all plans
 eagle-mem memories plans search "migration"
 eagle-mem memories plans show <file_path>
 ```
 
-**Tasks** -- Claude Code's task JSON (`~/.claude/tasks/<session>/*.json`). Individual units of work with status tracking (pending/in_progress/completed).
+**Tasks** -- Claude Code task JSON (`~/.claude/tasks/<session>/*.json`) and Eagle Mem task records created directly by agents such as Codex. Individual units of work with status tracking (pending/in_progress/completed).
 ```bash
 eagle-mem memories tasks                   # all tasks
 eagle-mem memories tasks search "refactor"
@@ -68,13 +68,13 @@ eagle-mem memories tasks show <file_path>
 
 Two paths feed the mirror:
 
-**Real-time (PostToolUse hook).** Every time Claude Code writes or edits a memory file, plan file, or creates/updates a task, the hook intercepts it and mirrors it into Eagle Mem's SQLite with FTS5 indexing. This happens automatically -- no user action needed.
+**Real-time hooks.** Claude Code memory/plan/task files are mirrored when written. Codex sessions are captured through SessionStart/UserPromptSubmit/PostToolUse/Stop hooks, and important durable facts should be placed in `<eagle-summary>` so they become shared recall.
 
-**Backfill (sync command).** For memories, plans, and tasks that existed before Eagle Mem was installed, or that were written outside a Claude Code session:
+**Backfill (sync command).** For memories, plans, and tasks that existed before Eagle Mem was installed, or that were written outside a hooked session:
 ```bash
 eagle-mem memories sync
 ```
-This scans all three directories, hashes each file, skips unchanged ones, and mirrors anything new or modified. It also backfills project names from Claude Code transcripts. Safe to run repeatedly -- content-hash dedup prevents double-insertion.
+This scans known Claude Code and Codex memory/task locations, hashes each file, skips unchanged ones, and mirrors anything new or modified. It also backfills project names from transcripts. Safe to run repeatedly -- content-hash dedup prevents double-insertion.
 
 ### 3. Search effectively
 
@@ -104,7 +104,7 @@ This asymmetry is intentional but easy to forget. If you're getting too many irr
 
 ### 5. Onboard an existing project
 
-When Eagle Mem is installed on a project that already has Claude Code history:
+When Eagle Mem is installed on a project that already has Claude Code or Codex history:
 ```bash
 eagle-mem memories sync
 ```
@@ -117,7 +117,7 @@ After sync or after expecting the hook to fire:
 eagle-mem memories list          # should show recent memories
 eagle-mem search --stats         # check counts are non-zero
 ```
-If memories list is empty after sync, check that `~/.claude/projects/` contains memory files for this project. If the hook isn't capturing new writes, check that PostToolUse hook is registered in settings.json.
+If memories list is empty after sync, check that `~/.claude/projects/` or `~/.codex/memories/` contains memory files. If the hook isn't capturing new writes, check Claude Code `settings.json` or Codex `hooks.json`.
 
 ## What makes a good memory lookup
 

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

@@ -10,9 +10,9 @@ description: >
 
 ## Purpose
 
-**For the user:** Multi-step work doesn't get lost when Claude Code compacts. A 6-task implementation plan survives intact across compactions — no re-explaining what was decided, no drift from the original direction.
+**For the user:** Multi-step work doesn't get lost when Claude Code or Codex compacts. A 6-task implementation plan survives intact across compactions — no re-explaining what was decided, no drift from the original direction.
 
-**For you (Claude Code):** Each task description is a message to a future context window with ZERO memory of what happened before. After compaction, SessionStart re-injects pending/in-progress tasks from Eagle Mem's `claude_tasks` table. That re-injected text is all the next context window gets. If the description says "implement auth middleware," the next window has nothing to work with. If it says "implement auth middleware — JWT with RS256, sessions in Redis, errors use RFC 7807 format (decided in task 1)," the next window can execute immediately.
+**For you:** Each task description is a message to a future context window with ZERO memory of what happened before. After compaction, SessionStart re-injects pending/in-progress tasks from Eagle Mem's `agent_tasks` table. That re-injected text is all the next context window gets. If the description says "implement auth middleware," the next window has nothing to work with. If it says "implement auth middleware — JWT with RS256, sessions in Redis, errors use RFC 7807 format (decided in task 1)," the next window can execute immediately.
 
 ## Judgment
 
@@ -42,12 +42,12 @@ Break the request into tasks that are each completable in one context window. Th
 
 ### 2. Create — write self-contained descriptions
 
-Use `TaskCreate` for each task. The description is the most important field — it must carry forward every decision from the planning conversation.
+Use the agent-native task mechanism when available. In Claude Code, use `TaskCreate`. In Codex, use `update_plan` for the live UI and `eagle-mem tasks add --agent codex` for durable cross-session task records. The description is the most important field — it must carry forward every decision from the planning conversation.
 
 **Context transfer pattern:** For each task, ask: "If I read only this description with zero prior context, can I execute it?" If not, add what's missing.
 
 ```
-TaskCreate:
+TaskCreate / eagle-mem tasks add:
   subject: "Add JWT auth middleware"
   description: "Add Express middleware that validates JWT tokens on protected
     routes. Decisions: RS256 algorithm, public key from env JWT_PUBLIC_KEY,
@@ -60,15 +60,15 @@ TaskCreate:
 
 ### 3. Execute — one task at a time
 
-`TaskUpdate(in_progress)` on the current task. Do the work. Stay focused on that task — don't drift into adjacent tasks.
+Mark the current task in progress (`TaskUpdate(in_progress)` in Claude Code, or `eagle-mem tasks start <id> --agent codex` in Codex). Do the work. Stay focused on that task — don't drift into adjacent tasks.
 
 ### 4. Complete — record what happened
 
-`TaskUpdate(completed)`. Emit `<eagle-summary>` so Eagle Mem captures what was accomplished.
+Mark the task completed (`TaskUpdate(completed)` in Claude Code, or `eagle-mem tasks complete <id> --agent codex` in Codex). Emit `<eagle-summary>` so Eagle Mem captures what was accomplished.
 
 If the task produced decisions that downstream tasks need, update those task descriptions now:
 ```
-TaskUpdate:
+TaskUpdate / update durable task description:
   taskId: "3"
   description: "...original description... Note from task 2: the user table
     uses UUID primary keys, not auto-increment. Auth tokens table FKs to
@@ -90,7 +90,7 @@ After compaction, SessionStart re-injects all pending/in-progress tasks. Pick th
 **A task fails or produces unexpected results:** Update the task description with what was learned and what went wrong. Don't just retry blindly — the description should carry the failure context so the next attempt (or the next context window) doesn't repeat the same mistake.
 
 ```
-TaskUpdate:
+TaskUpdate / task record update:
   taskId: "4"
   description: "...original description... FAILED ATTEMPT: Prisma migrate
     errored because the users table already has a conflicting unique
@@ -102,11 +102,11 @@ TaskUpdate:
 
 ## The compact cycle — how task state survives
 
-1. You call `TaskCreate`/`TaskUpdate` (Claude Code's native task tools)
-2. Claude Code writes task JSON to `~/.claude/tasks/$session_id/*.json`
-3. Eagle Mem's PostToolUse hook fires, mirrors the task into the `claude_tasks` FTS5 table
-4. SessionEnd hook does a final sweep to catch any status changes missed by hooks
-5. On compaction (or new session), SessionStart queries `claude_tasks` for pending/in-progress tasks from the last 7 days and injects them into context
+1. Claude Code path: you call `TaskCreate`/`TaskUpdate`; Claude Code writes task JSON to `~/.claude/tasks/$session_id/*.json`; Eagle Mem mirrors it.
+2. Codex path: you call `update_plan` for live progress and `eagle-mem tasks add/start/complete --agent codex` for durable records.
+3. Eagle Mem stores both paths in the shared `agent_tasks` FTS5 table with `origin_agent`.
+4. SessionEnd does a final Claude Code task sweep where native task files exist.
+5. On compaction (or new session), SessionStart queries `agent_tasks` for pending/in-progress tasks from the last 7 days and injects them into context.
 
 The task descriptions you write ARE the context that survives. Everything else — your reasoning, the conversation, the files you read — gets compacted away.
 
@@ -126,14 +126,20 @@ The bad version forces the next context window to re-discover every decision. Th
 ## Reference
 
 ```bash
-# Viewing tasks (read-only — Eagle Mem mirrors, doesn't manage)
+# Viewing tasks
 eagle-mem tasks                # pending/in-progress for current project
 eagle-mem tasks list           # all tasks (including completed)
 eagle-mem tasks completed      # completed tasks only
 eagle-mem tasks search <q>     # FTS5 search across task history
 eagle-mem tasks --json         # JSON output for scripting
 
-# Claude Code task tools (these are what you actually use)
+# Codex durable task records
+eagle-mem tasks add "Implement auth middleware" --agent codex --desc "Use RS256, Redis sessions, RFC 7807 errors"
+eagle-mem tasks update <id> --agent codex --desc "New context or failure details"
+eagle-mem tasks start <id> --agent codex
+eagle-mem tasks complete <id> --agent codex
+
+# Claude Code task tools
 TaskCreate                     # create a new task
 TaskUpdate                     # update status, description, dependencies
 ```