eagle-mem 4.6.2 → 4.7.1

package/hooks/pre-tool-use.sh

@@ -10,6 +10,7 @@
 # 6. Stuck loop detection (repeated edits to same file)
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -21,10 +22,11 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+agent=$(eagle_agent_source_from_json "$input")
 
 case "$tool_name" in
-    Bash|Read|Edit|Write) ;;
-    *) exit 0 ;;
+    Read|Edit|Write|apply_patch) ;;
+    *) eagle_is_shell_tool "$tool_name" || exit 0 ;;
 esac
 
 [ ! -f "$EAGLE_MEM_DB" ] && exit 0
@@ -38,27 +40,102 @@ context=""
 updated_input=""
 
 case "$tool_name" in
-Bash)
-    cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
+Bash|exec_command|shell_command|unified_exec)
+    cmd=$(eagle_tool_command_from_json "$input")
     [ -z "$cmd" ] && exit 0
 
-    # ─── Feature verification on git push ─────────────────────
+    # ─── Enforced feature verification on release boundaries ───
+
+    release_changed_files=""
+    if eagle_is_release_boundary_command "$cmd"; then
+        if [ -n "$cwd" ] && [ -d "$cwd" ]; then
+            release_changed_files=$(eagle_changed_files_for_release "$cwd")
+            eagle_reconcile_current_feature_verifications "$project" "$cwd" "$session_id" "$tool_name" "Release boundary detected for current repository diff" "$release_changed_files" >/dev/null
+        fi
+
+        pending_rows=$(eagle_list_current_pending_feature_verifications "$project" "$cwd" "$release_changed_files" 8 2>/dev/null)
+        pending_count=$(printf '%s\n' "$pending_rows" | sed '/^[[:space:]]*$/d' | wc -l | tr -d ' ')
+        pending_count=${pending_count:-0}
+        if [ "$pending_count" -gt 0 ] 2>/dev/null; then
+            block_reason="Eagle Mem blocked this release boundary because ${pending_count} feature verification(s) are pending.
+
+Run the affected smoke tests, then resolve them with:
+  eagle-mem feature verify <name> --notes \"what passed\"
+
+For intentional exceptions:
+  eagle-mem feature waive <id> --reason \"why this is safe\"
+
+Pending checks:"
+            while IFS='|' read -r pid pname pfile preason _ptrigger _pcreated psmoke pfingerprint; do
+                [ -z "$pid" ] && continue
+                block_reason+="
+  #${pid} ${pname}"
+                [ -n "$pfile" ] && block_reason+=" (${pfile})"
+                [ -n "$preason" ] && block_reason+=" — ${preason}"
+                [ -n "$psmoke" ] && block_reason+=" | smoke: ${psmoke}"
+                [ -n "$pfingerprint" ] && block_reason+=" | diff: ${pfingerprint}"
+            done <<< "$pending_rows"
+
+            jq -nc --arg reason "$block_reason" '{
+                "decision":"block",
+                "reason":$reason,
+                "hookSpecificOutput":{
+                    "hookEventName":"PreToolUse",
+                    "permissionDecision":"deny",
+                    "permissionDecisionReason":$reason
+                }
+            }'
+            exit 0
+        fi
+    fi
+
+    # ─── RTK command rewrite / enforcement ─────────────────
+
+    rtk_cmd=$(eagle_rtk_rewrite_command "$cmd")
+    if [ -n "$rtk_cmd" ]; then
+        if [ "$agent" = "codex" ] && ! eagle_raw_bash_unlock_active; then
+            reason="Eagle Mem token guard blocked raw shell output.
+
+Use RTK so large output is compact before it enters context:
+  $rtk_cmd
+
+Temporary escape hatch for one-off raw output:
+  touch $EAGLE_RAW_BASH_UNLOCK"
+            jq -nc --arg reason "$reason" '{
+                "decision":"block",
+                "reason":$reason,
+                "hookSpecificOutput":{
+                    "hookEventName":"PreToolUse",
+                    "permissionDecision":"deny",
+                    "permissionDecisionReason":$reason
+                }
+            }'
+            exit 0
+        fi
+
+        if ! eagle_raw_bash_unlock_active; then
+            updated_input=$(echo "$input" | jq --arg cmd "$rtk_cmd" '.tool_input + {"command":$cmd}')
+            context+="Eagle Mem token guard: rewrote raw shell command through RTK to reduce context load: ${rtk_cmd}. "
+        fi
+    fi
+
+    # ─── Feature verification context for non-blocked pushes ───
 
     case "$cmd" in
         *"git push"*|*"gh pr create"*)
             has_features=$(eagle_count_active_features "$project")
             if [ "${has_features:-0}" -gt 0 ]; then
-                changed_files=""
-                if [ -n "$cwd" ] && [ -d "$cwd" ]; then
-                    changed_files=$(git -C "$cwd" diff --name-only HEAD 2>/dev/null)
-                    [ -z "$changed_files" ] && changed_files=$(git -C "$cwd" diff --cached --name-only 2>/dev/null)
-                fi
+                    changed_files="$release_changed_files"
+                    if [ -z "$changed_files" ] && [ -n "$cwd" ] && [ -d "$cwd" ]; then
+                        changed_files=$(eagle_changed_files_for_release "$cwd")
+                    fi
 
                 if [ -n "$changed_files" ]; then
                     seen_features=""
                     while IFS= read -r changed_file; do
                         [ -z "$changed_file" ] && continue
-                        fname=$(basename "$changed_file")
+                        norm_file=$(eagle_project_file_path "$cwd" "$changed_file")
+                        fname=$(basename "$norm_file")
 
                         feature_hits=$(eagle_find_feature_for_push "$project" "$fname")
 
@@ -91,6 +168,7 @@ ${context}================"
 
     # ─── Command output filtering (learned rules) ─────────────
 
+    if [ -z "$updated_input" ]; then
     base_cmd=$(echo "$cmd" | awk '{print $1}' | sed 's|.*/||')
     rule=$(eagle_get_command_rule "$project" "$base_cmd" "$cmd")
 
@@ -117,11 +195,18 @@ ${context}================"
                 ;;
         esac
     fi
+    fi
     ;;
 
-Edit|Write)
-    fp=$(echo "$input" | jq -r '.tool_input.file_path // empty')
-    if [ -n "$fp" ]; then
+Edit|Write|apply_patch)
+    target_files=$(echo "$input" | jq -r '.tool_input.file_path // empty')
+    if [ "$tool_name" = "apply_patch" ]; then
+        patch_cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
+        target_files=$(printf '%s\n' "$patch_cmd" | eagle_extract_apply_patch_files | sed '/^[[:space:]]*$/d' | awk '!seen[$0]++')
+    fi
+    if [ -n "$target_files" ]; then
+        while IFS= read -r fp; do
+            [ -z "$fp" ] && continue
         # ─── Guardrail + decision/gotcha surfacing ────────
         fname=$(basename "$fp")
         fname_stem="${fname%.*}"
@@ -188,6 +273,7 @@ Edit|Write)
             partners=${partners%, }
             context+="Eagle Mem recall: when you change '$(basename "$fp")' you usually also touch: $partners"
         fi
+        done <<< "$target_files"
     fi
     ;;
 
@@ -217,6 +303,13 @@ esac
 
 [ -z "$context" ] && [ -z "$updated_input" ] && exit 0
 
+if [ "$agent" = "codex" ]; then
+    # Codex PreToolUse currently supports deny decisions, but not advisory
+    # additionalContext or updatedInput. Deny paths above already returned JSON;
+    # non-blocking reminders are delivered through SessionStart/UserPromptSubmit.
+    exit 0
+fi
+
 if [ -n "$updated_input" ]; then
     jq -nc --arg ctx "$context" --argjson ui "$updated_input" \
         '{"hookSpecificOutput":{"hookEventName":"PreToolUse","updatedInput":$ui,"additionalContext":$ctx}}'

package/hooks/session-end.sh

@@ -5,6 +5,7 @@
 # Marks the session as completed
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -16,6 +17,7 @@ input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
 session_id=$(echo "$input" | jq -r '.session_id // empty')
+agent=$(eagle_agent_source_from_json "$input")
 [ -z "$session_id" ] && exit 0
 [ ! -f "$EAGLE_MEM_DB" ] && exit 0
 
@@ -30,7 +32,7 @@ if eagle_validate_session_id "$session_id"; then
     if [ -d "$task_dir" ]; then
         for task_file in "$task_dir"/*.json; do
             [ ! -f "$task_file" ] && continue
-            eagle_capture_claude_task "$task_file" "$session_id" "$project"
+            eagle_capture_agent_task "$task_file" "$session_id" "$project" "$agent"
         done
         eagle_log "INFO" "SessionEnd: re-synced tasks from $task_dir"
     fi

package/hooks/session-start.sh

@@ -5,6 +5,7 @@
 # Injects project memory + pending tasks into Claude's context
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -24,6 +25,8 @@ session_id=$(echo "$input" | jq -r '.session_id // empty')
 cwd=$(echo "$input" | jq -r '.cwd // empty')
 source_type=$(echo "$input" | jq -r '.source // empty')
 model=$(echo "$input" | jq -r '.model // empty')
+agent=$(eagle_agent_source_from_json "$input")
+agent_label=$(eagle_agent_label "$agent")
 
 [ -z "$session_id" ] && exit 0
 
@@ -32,9 +35,9 @@ project=$(eagle_project_from_cwd "$cwd")
 
 p_esc=$(eagle_sql_escape "$project")
 
-eagle_log "INFO" "SessionStart: session=$session_id project=$project source=$source_type"
+eagle_log "INFO" "SessionStart: session=$session_id project=$project source=$source_type agent=$agent"
 
-eagle_upsert_session "$session_id" "$project" "$cwd" "$model" "$source_type"
+eagle_upsert_session "$session_id" "$project" "$cwd" "$model" "$source_type" "$agent"
 eagle_abandon_stale_sessions "$session_id"
 
 # ─── Reset turn counter on compact/clear ─────────────────
@@ -90,7 +93,8 @@ fi
 
 # ─── Gather stats ────────────────────────────────────────
 
-stat_sessions=0; stat_summaries=0; stat_with_summaries=0; stat_memories=0
+stat_sessions=0; stat_sessions_claude=0; stat_sessions_codex=0
+stat_summaries=0; stat_with_summaries=0; stat_memories=0
 stat_tasks_pending=0; stat_tasks_progress=0; stat_tasks_done=0
 stat_chunks=0; stat_observations=0; stat_plans=0
 stat_last_active="never"; stat_last_summary=""
@@ -98,6 +102,8 @@ stat_last_active="never"; stat_last_summary=""
 while IFS='|' read -r key val; do
     case "$key" in
         sessions)        stat_sessions="$val" ;;
+        sessions_claude) stat_sessions_claude="$val" ;;
+        sessions_codex)  stat_sessions_codex="$val" ;;
         summaries)       stat_summaries="$val" ;;
         with_summaries)  stat_with_summaries="$val" ;;
         memories)        stat_memories="$val" ;;
@@ -132,7 +138,12 @@ eagle_banner="======================================
        Eagle Mem Recall Ready
 ======================================
  Project      | $project
+ Agent        | $agent_label
  Sessions     | $stat_sessions ($stat_with_summaries with summaries)"
+if [ "$stat_sessions_codex" -gt 0 ] || [ "$stat_sessions_claude" -gt 0 ]; then
+    eagle_banner+="
+ Sources      | Claude $stat_sessions_claude, Codex $stat_sessions_codex"
+fi
 [ "$stat_memories" -gt 0 ] && eagle_banner+="
  Memories     | $stat_memories stored"
 [ "$stat_plans" -gt 0 ] && eagle_banner+="
@@ -156,6 +167,13 @@ $update_notice
 "
 fi
 
+if [ "$agent" = "codex" ] && [ "${stat_with_summaries:-0}" -eq 0 ] 2>/dev/null; then
+    context+="
+=== Eagle Mem: Codex Capture Warming Up ===
+Codex hooks are active. End important turns with an <eagle-summary> block so future Claude Code and Codex sessions can recall decisions, gotchas, key files, and next steps from this project.
+"
+fi
+
 # ─── Project overview (capped at 500 chars) ──────────────
 
 overview=$(eagle_get_overview "$project")
@@ -188,10 +206,13 @@ if [ -n "$recent" ]; then
     context+="
 === Eagle Mem: Recent Recall ===
 "
-    while IFS='|' read -r request completed learned next_steps created_at decisions gotchas key_files; do
+    while IFS='|' read -r request completed learned next_steps created_at decisions gotchas key_files summary_agent; do
         [ -z "$request" ] && [ -z "$completed" ] && continue
+        summary_agent_label=$(eagle_agent_label "$summary_agent")
         context+="
 --- $created_at ---"
+        [ -n "$summary_agent" ] && context+="
+Source: $summary_agent_label"
         [ -n "$request" ] && context+="
 Request: $request"
         [ -n "$completed" ] && context+="
@@ -213,9 +234,9 @@ fi
 
 # ─── Memories (skip if none) ─────────────────────────────
 
-memories=$(eagle_db "SELECT memory_name, memory_type, description, file_path, updated_at,
+memories=$(eagle_db "SELECT memory_name, memory_type, description, file_path, updated_at, origin_agent,
     CAST(julianday('now') - julianday(updated_at) AS INTEGER) as days_ago
-    FROM claude_memories
+    FROM agent_memories
     WHERE project = '$p_esc'
     ORDER BY updated_at DESC
     LIMIT 5;")
@@ -223,8 +244,9 @@ if [ -n "$memories" ]; then
     context+="
 === Eagle Mem: Stored Memories ===
 "
-    while IFS='|' read -r mname mtype mdesc _fpath _updated days_ago; do
+    while IFS='|' read -r mname mtype mdesc _fpath _updated morigin days_ago; do
         [ -z "$mname" ] && continue
+        origin_label=$(eagle_agent_label "$morigin")
         age_label=""
         if [ -n "$days_ago" ] && [ "$days_ago" -gt 0 ] 2>/dev/null; then
             if [ "$days_ago" -eq 1 ]; then
@@ -235,28 +257,29 @@ if [ -n "$memories" ]; then
         else
             age_label=" (today)"
         fi
-        context+="  - [$mtype] $mname: $mdesc$age_label
+        context+="  - [$mtype][$origin_label] $mname: $mdesc$age_label
 "
     done <<< "$memories"
 fi
 
 # ─── Plans (skip if none) ────────────────────────────────
 
-plans=$(eagle_list_claude_plans "$project" 3)
+plans=$(eagle_list_agent_plans "$project" 3)
 if [ -n "$plans" ]; then
     context+="
 === Eagle Mem: Plans ===
 "
-    while IFS='|' read -r ptitle _pproj _fpath _updated; do
+    while IFS='|' read -r ptitle _pproj _fpath _updated porigin; do
         [ -z "$ptitle" ] && continue
-        context+="  - $ptitle
+        origin_label=$(eagle_agent_label "$porigin")
+        context+="  - [$origin_label] $ptitle
 "
     done <<< "$plans"
 fi
 
 # ─── Tasks (skip if none) ────────────────────────────────
 
-synced_tasks=$(eagle_db "SELECT subject, status, blocked_by FROM claude_tasks
+synced_tasks=$(eagle_db "SELECT subject, status, blocked_by, origin_agent FROM agent_tasks
     WHERE project = '$p_esc'
     AND status IN ('in_progress', 'pending')
     AND updated_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-7 days')
@@ -268,17 +291,40 @@ if [ -n "$synced_tasks" ]; then
     context+="
 === Eagle Mem: Tasks ===
 "
-    while IFS='|' read -r tsubject tstatus tblocked; do
+    while IFS='|' read -r tsubject tstatus tblocked torigin; do
         [ -z "$tsubject" ] && continue
+        origin_label=$(eagle_agent_label "$torigin")
         block_marker=""
         if [ "$tblocked" != "[]" ] && [ -n "$tblocked" ]; then
             block_marker=" (blocked)"
         fi
-        context+="  - [$tstatus] $tsubject$block_marker
+        context+="  - [$tstatus][$origin_label] $tsubject$block_marker
 "
     done <<< "$synced_tasks"
 fi
 
+# ─── Pending feature verifications ───────────────────────
+
+pending_features=$(eagle_list_pending_feature_verifications "$project" 10 2>/dev/null)
+if [ -n "$pending_features" ]; then
+    context+="
+=== Eagle Mem: Pending Feature Verification ===
+Release-boundary commands are blocked until these are verified or waived.
+"
+    while IFS='|' read -r pf_id pf_name pf_file pf_reason _pf_trigger _pf_created pf_smoke pfingerprint; do
+        [ -z "$pf_id" ] && continue
+        context+="  - #${pf_id} ${pf_name}"
+        [ -n "$pf_file" ] && context+=" (${pf_file})"
+        [ -n "$pf_reason" ] && context+=" — ${pf_reason}"
+        [ -n "$pf_smoke" ] && context+=" | smoke: ${pf_smoke}"
+        [ -n "$pfingerprint" ] && context+=" | diff: ${pfingerprint}"
+        context+="
+"
+    done <<< "$pending_features"
+    context+="Resolve with: eagle-mem feature verify <name> --notes \"what passed\"; or eagle-mem feature waive <id> --reason \"why safe\".
+"
+fi
+
 # ─── Core files (hot file hints from curator) ───────────
 
 hot_files=$(eagle_get_hot_files "$project")
@@ -334,12 +380,15 @@ 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>
 "
 fi
 
 if [ -n "$context" ]; then
-    echo "$context"
+    eagle_emit_context_for_agent "$agent" "SessionStart" "$context"
 fi
 
 exit 0

package/hooks/stop.sh

@@ -7,6 +7,7 @@
 # LLM enrichment fills in decisions/gotchas/key_files
 # ═══════════════════════════════════════════════════════════
 set +e
+[ "${EAGLE_MEM_DISABLE_HOOKS:-}" = "1" ] && exit 0
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB_DIR="$SCRIPT_DIR/../lib"
@@ -23,6 +24,8 @@ input=$(eagle_read_stdin)
 session_id=$(echo "$input" | jq -r '.session_id // empty')
 cwd=$(echo "$input" | jq -r '.cwd // empty')
 transcript_path=$(echo "$input" | jq -r '.transcript_path // empty')
+last_assistant_message=$(echo "$input" | jq -r '.last_assistant_message // empty')
+agent=$(eagle_agent_source_from_json "$input")
 
 [ -z "$session_id" ] && exit 0
 
@@ -33,25 +36,62 @@ agent_type=$(echo "$input" | jq -r '.agent_type // empty')
 project=$(eagle_project_from_cwd "$cwd")
 [ -z "$project" ] && exit 0
 
-eagle_log "INFO" "Stop: session=$session_id project=$project transcript=$transcript_path"
+eagle_log "INFO" "Stop: session=$session_id project=$project transcript=$transcript_path agent=$agent"
 
 # Ensure session exists (may not if SessionStart didn't fire)
-eagle_upsert_session "$session_id" "$project" "$cwd" "" ""
-
-[ -z "$transcript_path" ] || [ ! -f "$transcript_path" ] && exit 0
+eagle_upsert_session "$session_id" "$project" "$cwd" "" "" "$agent"
+
+# Reconcile from git diff, not only from edit-tool hooks. This keeps
+# anti-regression agent-agnostic: Claude, Codex, manual edits, and script edits
+# all become visible before a release boundary.
+if [ -n "$cwd" ] && [ -d "$cwd" ]; then
+    changed_files=$(eagle_changed_files_for_release "$cwd")
+    if [ -n "$changed_files" ]; then
+        eagle_reconcile_current_feature_verifications "$project" "$cwd" "$session_id" "Stop" "Repository diff detected at turn end" "$changed_files" >/dev/null
+    fi
+fi
 
 # ─── Primary: heuristic extraction from transcript ───────────
 
-request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null \
-    | grep -v '<local-command-caveat>' \
-    | grep -v '<system-reminder>' \
-    | grep -v '<command-name>' \
-    | grep -v '<command-message>' \
-    | grep -v '^\[{' \
-    | head -1 | cut -c1-500)
+request=""
+heuristic_reads=""
+heuristic_writes=""
+
+if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
+    request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null \
+        | grep -v '<local-command-caveat>' \
+        | grep -v '<system-reminder>' \
+        | grep -v '<command-name>' \
+        | grep -v '<command-message>' \
+        | grep -v '^\[{' \
+        | head -1 | cut -c1-500)
+
+    if [ -z "$request" ]; then
+        request=$(jq -r '
+            select(.type == "response_item" and .payload.role == "user")
+            | .payload.content
+            | if type == "string" then .
+              elif type == "array" then [.[]? | select(.type == "input_text" or .type == "text") | .text] | join(" ")
+              else "" end
+        ' "$transcript_path" 2>/dev/null \
+            | grep -v '<local-command-caveat>' \
+            | grep -v '<system-reminder>' \
+            | grep -v '<command-name>' \
+            | grep -v '<command-message>' \
+            | grep -v '^\[{' \
+            | head -1 | cut -c1-500)
+    fi
+
+    if [ -z "$request" ]; then
+        request=$(jq -r 'select(.type == "event_msg" and .payload.type == "user_message") | .payload.message // empty' "$transcript_path" 2>/dev/null \
+            | grep -v '<local-command-caveat>' \
+            | grep -v '<system-reminder>' \
+            | head -1 | cut -c1-500)
+    fi
 
-heuristic_reads=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
-heuristic_writes=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Write" or .name == "Edit") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+    heuristic_reads=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+    heuristic_writes=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Write" or .name == "Edit") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+fi
 
 files_read="[]"
 files_modified="[]"
@@ -70,17 +110,46 @@ notes=""
 decisions=""
 gotchas=""
 key_files=""
+affected_features=""
+verified_features=""
+regression_risks=""
 
 eagle_log "INFO" "Stop: heuristic extraction complete"
 
 # ─── Bonus: eagle-summary block overrides where present ──────
 
-text_content=$(jq -rs '
-    [.[] | select(.type == "assistant")] | last |
-    if . then
-        [.message.content[]? | select(.type == "text") | .text] | join("\n")
-    else "" end
-' "$transcript_path" 2>/dev/null)
+if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
+    text_content=$(jq -r -s '
+        [.[] | select(.type == "assistant")] | last |
+        if . then
+            [.message.content[]? | select(.type == "text") | .text] | join("\n")
+        else "" end
+    ' "$transcript_path" 2>/dev/null)
+
+    if [ -z "$text_content" ]; then
+        text_content=$(jq -r -s '
+            def content_text:
+                if type == "string" then .
+                elif type == "array" then
+                    [.[]? | select(.type == "output_text" or .type == "text") | (.text // empty)] | join("\n")
+                else "" end;
+
+            (
+                [.[] | select(.type == "response_item" and .payload.role == "assistant") | (.payload.content | content_text)]
+                | map(select(. != ""))
+                | last
+            ) // (
+                [.[] | select(.type == "event_msg" and .payload.type == "agent_message") | (.payload.message // "")]
+                | map(select(. != ""))
+                | last
+            ) // ""
+        ' "$transcript_path" 2>/dev/null)
+    fi
+fi
+
+if [ -z "$text_content" ]; then
+    text_content="$last_assistant_message"
+fi
 
 # Strip <private>...</private> blocks
 text_content=$(echo "$text_content" | sed -E '/<[Pp][Rr][Ii][Vv][Aa][Tt][Ee][^>]*>/,/<\/[Pp][Rr][Ii][Vv][Aa][Tt][Ee][[:space:]]*>/d')
@@ -99,7 +168,7 @@ if [ -n "$summary_block" ]; then
             $0 ~ "^"f":" {
                 sub("^"f":[[:space:]]*", ""); found=1; val=$0; next
             }
-            found && /^(request|investigated|learned|completed|next_steps|files_read|files_modified|notes|decisions|gotchas|key_files):/ { exit }
+            found && /^(request|investigated|learned|completed|next_steps|files_read|files_modified|notes|decisions|gotchas|key_files|affected_features|verified_features|regression_risks):/ { exit }
             found { val = val " " $0 }
             END { if (found) print val }
         '
@@ -114,6 +183,9 @@ if [ -n "$summary_block" ]; then
     _val=$(parse_field "$summary_block" "decisions");     [ -n "$_val" ] && decisions="$_val"
     _val=$(parse_field "$summary_block" "gotchas");       [ -n "$_val" ] && gotchas="$_val"
     _val=$(parse_field "$summary_block" "key_files");     [ -n "$_val" ] && key_files="$_val"
+    _val=$(parse_field "$summary_block" "affected_features"); [ -n "$_val" ] && affected_features="$_val"
+    _val=$(parse_field "$summary_block" "verified_features"); [ -n "$_val" ] && verified_features="$_val"
+    _val=$(parse_field "$summary_block" "regression_risks");  [ -n "$_val" ] && regression_risks="$_val"
 
     # Convert bracket-list to JSON array
     to_json_array() {
@@ -295,11 +367,33 @@ next_steps=$(echo "$next_steps" | eagle_redact)
 decisions=$(echo "$decisions" | eagle_redact)
 gotchas=$(echo "$gotchas" | eagle_redact)
 key_files=$(echo "$key_files" | eagle_redact)
+notes=$(echo "$notes" | eagle_redact)
+affected_features=$(echo "$affected_features" | eagle_redact)
+verified_features=$(echo "$verified_features" | eagle_redact)
+regression_risks=$(echo "$regression_risks" | eagle_redact)
+
+regression_notes=""
+[ -n "$affected_features" ] && regression_notes+="affected_features: $affected_features"
+if [ -n "$verified_features" ]; then
+    [ -n "$regression_notes" ] && regression_notes+="; "
+    regression_notes+="verified_features: $verified_features"
+fi
+if [ -n "$regression_risks" ]; then
+    [ -n "$regression_notes" ] && regression_notes+="; "
+    regression_notes+="regression_risks: $regression_risks"
+fi
+if [ -n "$regression_notes" ]; then
+    if [ -n "$notes" ]; then
+        notes="${notes}; ${regression_notes}"
+    else
+        notes="$regression_notes"
+    fi
+fi
 
 # ─── Write to database ─────────────────────────────────────
 
 if [ -n "$request" ] || [ -n "$completed" ] || [ -n "$learned" ]; then
-    if eagle_insert_summary "$session_id" "$project" "$request" "$investigated" "$learned" "$completed" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files"; then
+    if eagle_insert_summary "$session_id" "$project" "$request" "$investigated" "$learned" "$completed" "$next_steps" "$files_read" "$files_modified" "$notes" "$decisions" "$gotchas" "$key_files" "$agent"; then
         eagle_log "INFO" "Stop: summary saved for session=$session_id"
     else
         eagle_log "ERROR" "Stop: summary insert FAILED for session=$session_id — check DB constraints"