eagle-mem 4.6.2 → 4.7.1

package/hooks/user-prompt-submit.sh

@@ -5,6 +5,7 @@
 # Searches memory for relevant context and injects it
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -20,6 +21,7 @@ input=$(eagle_read_stdin)
 session_id=$(echo "$input" | jq -r '.session_id // empty')
 cwd=$(echo "$input" | jq -r '.cwd // empty')
 user_prompt=$(echo "$input" | jq -r '.prompt // empty')
+agent=$(eagle_agent_source_from_json "$input")
 
 [ -z "$user_prompt" ] && exit 0
 
@@ -60,7 +62,10 @@ fi
 
 # Skip short prompts — not enough signal for meaningful search
 word_count=$(echo "$user_prompt" | wc -w | tr -d ' ')
-[ "$word_count" -lt 3 ] && { [ -n "$context" ] && echo "$context"; exit 0; }
+if [ "$word_count" -lt 3 ]; then
+    eagle_emit_context_for_agent "$agent" "UserPromptSubmit" "$context"
+    exit 0
+fi
 
 # Build FTS5 query from significant words (drop stop words, take first 6)
 fts_query=$(echo "$user_prompt" | tr -cs '[:alnum:]' ' ' | tr '[:upper:]' '[:lower:]' | \
@@ -75,7 +80,10 @@ fts_query=$(echo "$user_prompt" | tr -cs '[:alnum:]' ' ' | tr '[:upper:]' '[:low
         }
     }')
 
-[ -z "$fts_query" ] && { [ -n "$context" ] && echo "$context"; exit 0; }
+if [ -z "$fts_query" ]; then
+    eagle_emit_context_for_agent "$agent" "UserPromptSubmit" "$context"
+    exit 0
+fi
 
 # Search for relevant past summaries (cross-session)
 results=$(eagle_search_summaries "$fts_query" "$project" 3)
@@ -83,9 +91,10 @@ results=$(eagle_search_summaries "$fts_query" "$project" 3)
 if [ -n "$results" ]; then
     context+="=== Eagle Mem: Relevant Recall ===
 "
-    while IFS='|' read -r req completed learned _next_steps created_at _proj decisions gotchas key_files; do
+    while IFS='|' read -r req completed learned _next_steps created_at _proj decisions gotchas key_files summary_agent; do
         [ -z "$req" ] && [ -z "$completed" ] && continue
-        context+="[$created_at] "
+        origin_label=$(eagle_agent_label "$summary_agent")
+        context+="[$created_at][$origin_label] "
         [ -n "$req" ] && context+="$req"
         [ -n "$completed" ] && context+=" → $completed"
         [ -n "$learned" ] && context+=" (Learned: $learned)"
@@ -126,5 +135,5 @@ IMPORTANT: When Eagle Mem finds relevant memories or code for the user's prompt,
 === Eagle Mem: Persistent Memory ===
 "
 
-echo "$context"
+eagle_emit_context_for_agent "$agent" "UserPromptSubmit" "$context"
 exit 0

package/lib/codex-hooks.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Codex hook registration helpers
+# Shared by install.sh, update.sh, and uninstall.sh
+# ═══════════════════════════════════════════════════════════
+[ -n "${_EAGLE_CODEX_HOOKS_LOADED:-}" ] && return 0
+_EAGLE_CODEX_HOOKS_LOADED=1
+
+eagle_enable_codex_hooks() {
+    local config="$EAGLE_CODEX_CONFIG"
+    mkdir -p "$(dirname "$config")"
+
+    if [ ! -f "$config" ]; then
+        cat > "$config" << 'TOML'
+[features]
+codex_hooks = true
+TOML
+        chmod 600 "$config" 2>/dev/null || true
+        return 0
+    fi
+
+    local tmp
+    tmp=$(mktemp)
+    awk '
+        BEGIN { in_features=0; saw_features=0; saw_flag=0; inserted=0 }
+        /^[[:space:]]*\[features\][[:space:]]*$/ {
+            saw_features=1
+            in_features=1
+            print
+            next
+        }
+        /^[[:space:]]*\[/ && in_features {
+            if (!saw_flag && !inserted) {
+                print "codex_hooks = true"
+                inserted=1
+            }
+            in_features=0
+        }
+        in_features && /^[[:space:]]*codex_hooks[[:space:]]*=/ {
+            print "codex_hooks = true"
+            saw_flag=1
+            next
+        }
+        { print }
+        END {
+            if (in_features && !saw_flag && !inserted) {
+                print "codex_hooks = true"
+                inserted=1
+            }
+            if (!saw_features) {
+                print ""
+                print "[features]"
+                print "codex_hooks = true"
+            }
+        }
+    ' "$config" > "$tmp" && mv "$tmp" "$config"
+    chmod 600 "$config" 2>/dev/null || true
+}
+
+eagle_patch_codex_hook() {
+    local hooks_file="$1"
+    local event="$2"
+    local matcher="$3"
+    local command="$4"
+    local description="${5:-}"
+    local status_message="${6:-}"
+    local timeout="${7:-}"
+    local script_path="$command"
+    script_path="${script_path#EAGLE_AGENT_SOURCE=codex bash \"}"
+    script_path="${script_path#bash \"}"
+    script_path="${script_path%\"}"
+
+    mkdir -p "$(dirname "$hooks_file")"
+    if [ ! -f "$hooks_file" ]; then
+        printf '{"hooks":{}}\n' > "$hooks_file"
+        chmod 600 "$hooks_file" 2>/dev/null || true
+    fi
+
+    local match_query
+    if [ -n "$matcher" ]; then
+        match_query='.hooks[$event][]? | select(.matcher == $matcher and (.hooks[]?.command == $command))'
+    else
+        match_query='.hooks[$event][]? | select((.matcher == null or .matcher == "") and (.hooks[]?.command == $command))'
+    fi
+    if jq -e --arg event "$event" --arg matcher "$matcher" --arg command "$command" "$match_query" "$hooks_file" &>/dev/null; then
+        [ -n "$description" ] && eagle_ok "$description ${DIM}(already registered)${RESET}"
+        return 0
+    fi
+
+    if jq -e --arg event "$event" --arg matcher "$matcher" --arg script "$script_path" '
+        .hooks[$event][]?
+        | select((($matcher == "" and (.matcher == null or .matcher == "")) or .matcher == $matcher)
+                 and any(.hooks[]?; (.command // "") | contains($script)))
+    ' "$hooks_file" &>/dev/null; then
+        local tmp_existing
+        tmp_existing=$(mktemp)
+        jq --arg event "$event" --arg matcher "$matcher" --arg script "$script_path" --arg command "$command" '
+            .hooks[$event] |= map(
+                if ((($matcher == "" and (.matcher == null or .matcher == "")) or .matcher == $matcher)
+                    and any(.hooks[]?; (.command // "") | contains($script)))
+                then .hooks |= map(if ((.command // "") | contains($script)) then .command = $command else . end)
+                else .
+                end
+            )
+        ' "$hooks_file" > "$tmp_existing" && mv "$tmp_existing" "$hooks_file"
+        [ -n "$description" ] && eagle_ok "$description ${DIM}(updated)${RESET}"
+        return 0
+    fi
+
+    local entry
+    entry=$(jq -nc \
+        --arg m "$matcher" \
+        --arg c "$command" \
+        --arg s "$status_message" \
+        --arg timeout "$timeout" '
+        {
+            hooks: [
+                {
+                    type: "command",
+                    command: $c
+                }
+                + (if $s == "" then {} else {statusMessage: $s} end)
+                + (if $timeout == "" then {} else {timeout: ($timeout | tonumber)} end)
+            ]
+        }
+        + (if $m == "" then {} else {matcher: $m} end)')
+
+    local tmp
+    tmp=$(mktemp)
+    jq --argjson entry "$entry" ".hooks.${event} = ((.hooks.${event} // []) + [\$entry])" "$hooks_file" > "$tmp" && mv "$tmp" "$hooks_file"
+    chmod 600 "$hooks_file" 2>/dev/null || true
+    [ -n "$description" ] && eagle_ok "$description"
+}
+
+eagle_register_codex_hooks() {
+    eagle_enable_codex_hooks
+
+    eagle_patch_codex_hook "$EAGLE_CODEX_HOOKS" "SessionStart" "startup|resume|clear" \
+        "EAGLE_AGENT_SOURCE=codex bash \"$EAGLE_MEM_DIR/hooks/session-start.sh\"" \
+        "Codex SessionStart hook" \
+        "Loading Eagle Mem recall" \
+        "30"
+
+    eagle_patch_codex_hook "$EAGLE_CODEX_HOOKS" "UserPromptSubmit" "" \
+        "EAGLE_AGENT_SOURCE=codex bash \"$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh\"" \
+        "Codex UserPromptSubmit hook" \
+        "Searching Eagle Mem" \
+        "30"
+
+    eagle_patch_codex_hook "$EAGLE_CODEX_HOOKS" "PreToolUse" "^(Bash|exec_command|shell_command|unified_exec|apply_patch|Edit|Write)$" \
+        "EAGLE_AGENT_SOURCE=codex bash \"$EAGLE_MEM_DIR/hooks/pre-tool-use.sh\"" \
+        "Codex PreToolUse hook" \
+        "Checking Eagle Mem guardrails" \
+        "30"
+
+    eagle_patch_codex_hook "$EAGLE_CODEX_HOOKS" "PostToolUse" "^(Bash|exec_command|shell_command|unified_exec|apply_patch|Edit|Write)$" \
+        "EAGLE_AGENT_SOURCE=codex bash \"$EAGLE_MEM_DIR/hooks/post-tool-use.sh\"" \
+        "Codex PostToolUse hook" \
+        "Recording Eagle Mem observation" \
+        "30"
+
+    eagle_patch_codex_hook "$EAGLE_CODEX_HOOKS" "Stop" "" \
+        "EAGLE_AGENT_SOURCE=codex bash \"$EAGLE_MEM_DIR/hooks/stop.sh\"" \
+        "Codex Stop hook" \
+        "Saving Eagle Mem summary" \
+        "30"
+}
+
+eagle_remove_codex_hooks() {
+    local hooks_file="$EAGLE_CODEX_HOOKS"
+    [ -f "$hooks_file" ] || return 1
+    command -v jq &>/dev/null || return 1
+
+    local tmp
+    tmp=$(mktemp)
+    jq '
+        def without_eagle_mem_handlers:
+            .hooks = ((.hooks // [])
+                | map(select(((.command // "") | contains(".eagle-mem/hooks/")) | not)));
+
+        if .hooks then
+            .hooks |= with_entries(
+                .value = [
+                    .value[]?
+                    | without_eagle_mem_handlers
+                    | select((.hooks // []) | length > 0)
+                ]
+                | select(.value != [])
+            )
+        else . end
+        | if .hooks == {} then del(.hooks) else . end
+    ' "$hooks_file" > "$tmp" && mv "$tmp" "$hooks_file"
+    chmod 600 "$hooks_file" 2>/dev/null || true
+}

package/lib/common.sh

@@ -12,6 +12,13 @@ EAGLE_SKILLS_DIR="$HOME/.claude/skills"
 EAGLE_CLAUDE_PROJECTS_DIR="$HOME/.claude/projects"
 EAGLE_CLAUDE_PLANS_DIR="$HOME/.claude/plans"
 EAGLE_CLAUDE_TASKS_DIR="$HOME/.claude/tasks"
+EAGLE_CODEX_DIR="${EAGLE_CODEX_DIR:-$HOME/.codex}"
+EAGLE_CODEX_CONFIG="${EAGLE_CODEX_CONFIG:-$EAGLE_CODEX_DIR/config.toml}"
+EAGLE_CODEX_HOOKS="${EAGLE_CODEX_HOOKS:-$EAGLE_CODEX_DIR/hooks.json}"
+EAGLE_CODEX_AGENTS_MD="${EAGLE_CODEX_AGENTS_MD:-$EAGLE_CODEX_DIR/AGENTS.md}"
+EAGLE_CODEX_SKILLS_DIR="${EAGLE_CODEX_SKILLS_DIR:-$EAGLE_CODEX_DIR/skills}"
+EAGLE_CODEX_MEMORIES_DIR="${EAGLE_CODEX_MEMORIES_DIR:-$EAGLE_CODEX_DIR/memories}"
+EAGLE_RAW_BASH_UNLOCK="${EAGLE_RAW_BASH_UNLOCK:-/tmp/eagle-mem-raw-bash-unlock}"
 
 eagle_log() {
     local level="$1"
@@ -63,6 +70,289 @@ eagle_project_from_cwd() {
     fi
 }
 
+eagle_project_file_path() {
+    local cwd="${1:-$(pwd)}"
+    local file_path="${2:-}"
+
+    [ -z "$file_path" ] && return 0
+
+    case "$file_path" in
+        ./*) file_path="${file_path#./}" ;;
+    esac
+
+    case "$file_path" in
+        /*)
+            local git_root
+            git_root=$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)
+            if [ -n "$git_root" ]; then
+                case "$file_path" in
+                    "$git_root"/*)
+                        printf '%s\n' "${file_path#$git_root/}"
+                        return 0
+                        ;;
+                esac
+            fi
+            case "$file_path" in
+                "$cwd"/*)
+                    printf '%s\n' "${file_path#$cwd/}"
+                    return 0
+                    ;;
+            esac
+            ;;
+    esac
+
+    printf '%s\n' "$file_path"
+}
+
+eagle_extract_apply_patch_files() {
+    sed -n -E 's/^\*\*\* (Add|Update|Delete) File: //p'
+}
+
+eagle_agent_source() {
+    local agent="${EAGLE_AGENT_SOURCE:-${EAGLE_AGENT:-}}"
+    case "$agent" in
+        codex|openai-codex) echo "codex" ;;
+        claude|claude-code|cloud-code) echo "claude-code" ;;
+        *) echo "claude-code" ;;
+    esac
+}
+
+eagle_agent_source_from_json() {
+    local input="${1:-}"
+    local configured="${EAGLE_AGENT_SOURCE:-${EAGLE_AGENT:-}}"
+    if [ -n "$configured" ]; then
+        eagle_agent_source
+        return
+    fi
+
+    local transcript_path turn_id tool_name
+    transcript_path=$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)
+    turn_id=$(printf '%s' "$input" | jq -r '.turn_id // empty' 2>/dev/null)
+    tool_name=$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)
+
+    case "$transcript_path" in
+        "$HOME/.codex/"*|*/.codex/*) echo "codex"; return ;;
+        "$HOME/.claude/"*|*/.claude/*) echo "claude-code"; return ;;
+    esac
+    [ -n "$turn_id" ] && { echo "codex"; return; }
+    [ "$tool_name" = "apply_patch" ] && { echo "codex"; return; }
+
+    echo "claude-code"
+}
+
+eagle_agent_label() {
+    case "${1:-$(eagle_agent_source)}" in
+        codex) echo "Codex" ;;
+        *) echo "Claude Code" ;;
+    esac
+}
+
+eagle_is_shell_tool() {
+    case "${1:-}" in
+        Bash|exec_command|shell_command|unified_exec) return 0 ;;
+        *) return 1 ;;
+    esac
+}
+
+eagle_tool_command_from_json() {
+    local input="${1:-}"
+    printf '%s' "$input" | jq -r '
+        .tool_input.command
+        // .tool_input.cmd
+        // .tool_input.shell_command
+        // .tool_input.command_line
+        // .tool_input.cmdline
+        // (if (.tool_input.argv? | type) == "array" then (.tool_input.argv | join(" ")) else empty end)
+        // empty
+    ' 2>/dev/null
+}
+
+eagle_emit_context_for_agent() {
+    local agent="${1:-$(eagle_agent_source)}"
+    local hook_event="${2:-}"
+    local context="${3:-}"
+
+    [ -z "$context" ] && return 0
+
+    if [ "$agent" = "codex" ]; then
+        jq -cn \
+            --arg event "$hook_event" \
+            --arg context "$context" \
+            '{
+                hookSpecificOutput: {
+                    hookEventName: $event,
+                    additionalContext: $context
+                }
+            }'
+        return 0
+    fi
+
+    printf '%s\n' "$context"
+}
+
+eagle_rtk_rewrite_command() {
+    local cmd="$1"
+    command -v rtk >/dev/null 2>&1 || return 1
+
+    case "$cmd" in
+        ""|rtk\ *|*" rtk "*|*"eagle-mem "*|*"git push"*|*"gh pr create"*|*"npm publish"*|*"pnpm publish"*|*"yarn npm publish"*|*"bun publish"*)
+            return 1
+            ;;
+    esac
+
+    local rewritten
+    rewritten=$(rtk rewrite "$cmd" 2>/dev/null | head -1)
+    [ -z "$rewritten" ] && return 1
+    [ "$rewritten" = "$cmd" ] && return 1
+    printf '%s\n' "$rewritten"
+}
+
+eagle_raw_bash_unlock_active() {
+    [ -f "$EAGLE_RAW_BASH_UNLOCK" ] || return 1
+    local now mtime age
+    now=$(date +%s)
+    mtime=$(stat -f %m "$EAGLE_RAW_BASH_UNLOCK" 2>/dev/null || stat -c %Y "$EAGLE_RAW_BASH_UNLOCK" 2>/dev/null || echo 0)
+    age=$((now - mtime))
+    [ "$age" -lt 600 ]
+}
+
+eagle_sha256_stream() {
+    if command -v shasum >/dev/null 2>&1; then
+        shasum -a 256 | awk '{print $1}'
+    else
+        sha256sum | awk '{print $1}'
+    fi
+}
+
+eagle_is_release_boundary_command() {
+    local cmd="$1"
+
+    if printf '%s\n' "$cmd" \
+        | tr '\n' ';' \
+        | sed -E 's/(&&|[|][|]|;)/\
+/g' \
+        | awk '
+            function has_dry_run_flag(line) {
+                return line ~ /(^|[[:space:]])--dry-run([[:space:]]|$|=([Tt][Rr][Uu][Ee]|1|[Yy][Ee][Ss])([[:space:]]|$))/
+            }
+            /(^|[[:space:]])gh[[:space:]]+pr[[:space:]]+create([[:space:]]|$)/ ||
+            /(^|[[:space:]])npm[[:space:]]+publish([[:space:]]|$)/ ||
+            /(^|[[:space:]])pnpm[[:space:]]+publish([[:space:]]|$)/ ||
+            /(^|[[:space:]])yarn[[:space:]]+npm[[:space:]]+publish([[:space:]]|$)/ ||
+            /(^|[[:space:]])bun[[:space:]]+publish([[:space:]]|$)/ {
+                if (!has_dry_run_flag($0)) found = 1
+            }
+            END { exit(found ? 0 : 1) }
+        '
+    then
+        return 0
+    fi
+
+    if printf '%s\n' "$cmd" \
+        | tr '\n' ';' \
+        | sed -E 's/(&&|[|][|]|;)/\
+/g' \
+        | awk '
+            function has_dry_run_flag(line) {
+                return line ~ /(^|[[:space:]])--dry-run([[:space:]]|$|=([Tt][Rr][Uu][Ee]|1|[Yy][Ee][Ss])([[:space:]]|$))/
+            }
+            /(^|[[:space:]])git[[:space:]]+push([[:space:]]|$)/ {
+                if (!has_dry_run_flag($0)) found = 1
+            }
+            END { exit(found ? 0 : 1) }
+        '
+    then
+        return 0
+    fi
+
+    return 1
+}
+
+eagle_changed_files_for_release() {
+    local cwd="${1:-$(pwd)}"
+    [ -d "$cwd" ] || return 0
+
+    {
+        git -C "$cwd" diff --name-only HEAD 2>/dev/null
+        git -C "$cwd" diff --cached --name-only 2>/dev/null
+        local default_branch
+        default_branch=$(git -C "$cwd" symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null | sed 's|^origin/||')
+        if [ -n "$default_branch" ] && git -C "$cwd" rev-parse --verify "origin/$default_branch" >/dev/null 2>&1; then
+            git -C "$cwd" diff --name-only "origin/$default_branch...HEAD" 2>/dev/null
+        fi
+        if git -C "$cwd" rev-parse --abbrev-ref --symbolic-full-name '@{upstream}' >/dev/null 2>&1; then
+            git -C "$cwd" diff --name-only '@{upstream}...HEAD' 2>/dev/null
+        fi
+        if ! git -C "$cwd" rev-parse --abbrev-ref --symbolic-full-name '@{upstream}' >/dev/null 2>&1; then
+            if ! git -C "$cwd" symbolic-ref --quiet --short refs/remotes/origin/HEAD >/dev/null 2>&1; then
+                if git -C "$cwd" rev-parse --verify HEAD~1 >/dev/null 2>&1; then
+                    git -C "$cwd" diff --name-only HEAD~1..HEAD 2>/dev/null
+                fi
+            fi
+        fi
+    } | sed '/^[[:space:]]*$/d' | sort -u
+}
+
+eagle_change_fingerprint_for_file() {
+    local cwd="${1:-$(pwd)}"
+    local file_path="${2:-}"
+    [ -z "$file_path" ] && return 0
+    [ -d "$cwd" ] || return 0
+
+    local git_root
+    git_root=$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null)
+    [ -z "$git_root" ] && return 0
+
+    local rel_path="$file_path"
+    case "$rel_path" in
+        ./*) rel_path="${rel_path#./}" ;;
+        /*)
+            case "$rel_path" in
+                "$git_root"/*) rel_path="${rel_path#$git_root/}" ;;
+                "$cwd"/*) rel_path="${rel_path#$cwd/}" ;;
+            esac
+            ;;
+    esac
+
+    local base_ref=""
+    local default_branch
+    default_branch=$(git -C "$git_root" symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null | sed 's|^origin/||')
+    if [ -n "$default_branch" ] && git -C "$git_root" rev-parse --verify "origin/$default_branch" >/dev/null 2>&1; then
+        base_ref=$(git -C "$git_root" merge-base HEAD "origin/$default_branch" 2>/dev/null)
+    fi
+
+    if [ -z "$base_ref" ] && git -C "$git_root" rev-parse --abbrev-ref --symbolic-full-name '@{upstream}' >/dev/null 2>&1; then
+        base_ref=$(git -C "$git_root" merge-base HEAD '@{upstream}' 2>/dev/null)
+    fi
+
+    if [ -z "$base_ref" ]; then
+        if ! git -C "$git_root" diff --quiet HEAD -- "$rel_path" 2>/dev/null \
+            || ! git -C "$git_root" diff --cached --quiet HEAD -- "$rel_path" 2>/dev/null \
+            || git -C "$git_root" ls-files --others --exclude-standard -- "$rel_path" 2>/dev/null | grep -qxF "$rel_path"
+        then
+            base_ref="HEAD"
+        elif git -C "$git_root" rev-parse --verify HEAD~1 >/dev/null 2>&1; then
+            base_ref="HEAD~1"
+        else
+            base_ref="HEAD"
+        fi
+    fi
+
+    local base_blob="missing"
+    if [ -n "$base_ref" ] && git -C "$git_root" cat-file -e "$base_ref:$rel_path" 2>/dev/null; then
+        base_blob=$(git -C "$git_root" rev-parse "$base_ref:$rel_path" 2>/dev/null)
+    fi
+
+    local final_blob="missing"
+    if [ -f "$git_root/$rel_path" ]; then
+        final_blob=$(git -C "$git_root" hash-object -- "$rel_path" 2>/dev/null)
+    elif git -C "$git_root" cat-file -e "HEAD:$rel_path" 2>/dev/null; then
+        final_blob=$(git -C "$git_root" rev-parse "HEAD:$rel_path" 2>/dev/null)
+    fi
+
+    printf 'file:%s\nbase:%s\nfinal:%s\n' "$rel_path" "$base_blob" "$final_blob" | eagle_sha256_stream
+}
+
 eagle_sql_escape() {
     printf '%s' "$1" | sed "s/'/''/g"
 }
@@ -189,6 +479,9 @@ next_steps: [concrete actions]
 key_files: [path — role]
 files_read: [path, ...]
 files_modified: [path, ...]
+affected_features: [feature, ...]
+verified_features: [feature, ...]
+regression_risks: [risk, ...]
 </eagle-summary>
 ```
 
@@ -198,6 +491,7 @@ files_modified: [path, ...]
 - Emit `<eagle-summary>` before your final text response, every session
 - When Eagle Mem injects context at SessionStart, attribute it: "Eagle Mem recalls:"
 - Do not revert decisions surfaced by PostToolUse without asking the user
+- If Eagle Mem reports pending feature verification, verify or waive it before push/PR/publish
 - Never put raw secrets in the summary — Eagle Mem redacts but defense in depth
 - If you contradict a loaded memory, update the memory file
 EAGLE_MD
@@ -233,3 +527,54 @@ eagle_patch_claude_md() {
 
     _eagle_claude_md_section >> "$claude_md"
 }
+
+_eagle_codex_agents_section() {
+    cat << 'EAGLE_AGENTS'
+
+---
+
+## Eagle Mem — Persistent Memory
+
+Eagle Mem hooks are active for Codex in this project. SessionStart and UserPromptSubmit inject project recall from the shared Eagle Mem database at `~/.eagle-mem/memory.db`. PostToolUse records observations and marks affected features for verification.
+
+**Rule:** Before your final response in every session, emit an `<eagle-summary>` block so the Stop hook can capture a rich summary.
+
+```
+<eagle-summary>
+request: [what user asked]
+completed: [what shipped]
+learned: [non-obvious discoveries]
+decisions: [choice — why]
+gotchas: [what surprised]
+next_steps: [concrete actions]
+key_files: [path — role]
+files_read: [path, ...]
+files_modified: [path, ...]
+affected_features: [feature, ...]
+verified_features: [feature, ...]
+regression_risks: [risk, ...]
+</eagle-summary>
+```
+
+**How to apply:**
+- Attribute recalled context as "Eagle Mem recalls:" when it is injected
+- Use the Eagle Mem skills when relevant: `eagle-mem-search`, `eagle-mem-overview`, `eagle-mem-memories`, and `eagle-mem-tasks`
+- For important decisions, preferences, gotchas, or durable project facts, explicitly include them in the `<eagle-summary>` block so Codex-originated memories become available to future Claude Code and Codex sessions
+- Do not revert Eagle Mem-surfaced decisions without asking the user
+- If Eagle Mem reports pending feature verification, verify or waive it before push/PR/publish
+- Never put raw secrets in summaries
+EAGLE_AGENTS
+}
+
+eagle_patch_codex_agents_md() {
+    local agents_md="$EAGLE_CODEX_AGENTS_MD"
+    local marker="## Eagle Mem — Persistent Memory"
+
+    mkdir -p "$(dirname "$agents_md")"
+
+    if [ -f "$agents_md" ] && grep -qF "$marker" "$agents_md" 2>/dev/null; then
+        return 1
+    fi
+
+    _eagle_codex_agents_section >> "$agents_md"
+}

package/lib/db-backfill.sh

@@ -65,9 +65,9 @@ eagle_backfill_projects() {
         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 agent_tasks SET project = '$proj_sql' WHERE source_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE agent_memories SET project = '$proj_sql' WHERE origin_session_id = '$sid_sql' AND (project = '' OR project != '$proj_sql');
+UPDATE agent_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();